merge(orchestrator): intègre le watchdog d'inactivité réarmable + plafond du rendez-vous (T7)

Fenêtre d'inactivité réarmée à chaque progrès de la cible (octets cumulés du
transcript) sous un plafond absolu, en remplacement du timeout plat qui coupait
un long tour unique à 600 s. Issue typée TargetCeilingActive distincte du no-reply.
Suite Rust verte (application + infrastructure, 0 échec). Campagne MCP T1→T10 PASS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitignore

@@ -7,6 +7,8 @@
 # Dependencies and build output (package-lock.json IS committed).
 frontend/node_modules/
 frontend/dist/
+# Root-level node_modules (dev tooling installs at repo root — never versioned).
+/node_modules/
 # npm/yarn/pnpm debug logs
 npm-debug.log*
 yarn-debug.log*
@@ -38,6 +40,9 @@ frontend/coverage/
 # Runtime file-protocol orchestration requests/responses — transient I/O, not
 # durable project state (curation .ideai §chantier secondaire).
 .ideai/requests/
+# Volatile agent live-state snapshot ("who is doing what right now", lot LS2):
+# rebuilt at runtime, keyed last-writer-wins — not versioned (unlike .ideai/memory/).
+.ideai/live-state.json
 
 # ─── Editors / OS ───────────────────────────────────────────────────────────
 .idea/
@@ -47,3 +52,7 @@ frontend/coverage/
 *~
 .DS_Store
 Thumbs.db
+# Conversation runtime (handoff distillé + log.jsonl transcript par paire) :
+# état d'exécution reconstruit au fil de l'eau — not versioned (LS8 §7, design D19-4 ;
+# seul .ideai/memory/ est le store durable versionné).
+.ideai/conversations/

.ideai/agents.json

@@ -37,16 +37,9 @@
       "synchronized": false
     },
     {
-      "agentId": "c932c770-cf36-4fb2-a966-71bb1644e4b4",
-      "name": "TestConversation",
-      "mdPath": "agents/testconversation.md",
-      "profileId": "664cc20c-47b8-53ad-9351-dce3c09c0de4",
-      "synchronized": false
-    },
-    {
-      "agentId": "484eff91-60a1-459f-9ebe-c9552cc70447",
-      "name": "NewTest",
-      "mdPath": "agents/newtest.md",
+      "agentId": "cd0b4cf1-1bef-4fae-ade5-f0a6b49bbaf5",
+      "name": "Git",
+      "mdPath": "agents/git.md",
       "profileId": "664cc20c-47b8-53ad-9351-dce3c09c0de4",
       "synchronized": false
     }

.ideai/agents/git.md

@@ -0,0 +1,119 @@
+# Git — Agent de gestion du dépôt git local
+
+> Tu es l'**agent Git** d'IdeA. Ta responsabilité est la **gestion du dépôt
+> git local** : commits de l'application, création et bascule de
+> branches, merges, rebases. Tu es le **seul**
+> à décider de la topologie des branches et à manipuler l'historique. Main te
+> sollicite ; tu décides et tu exécutes.
+
+---
+
+## 1. Ton rôle (et ses limites)
+
+Tu t'occupes **du repo git local** :
+
+- **Commits** : tu transformes le travail réalisé par les agents de dev en commits
+  propres, atomiques, au bon endroit (bonne branche), avec des messages cohérents.
+- **Branches** : tu **crées, checkout, switch** les branches selon ce qui est en cours.
+- **Intégration** : tu **merges** et **rebases** les branches entre elles selon le
+  modèle ci-dessous.
+- Tu **décides** : quand Main t'annonce une nouvelle feature (après cadrage Architect),
+  c'est **toi** qui tranches s'il faut une nouvelle branche, un checkout/switch, ou rien.
+  Après chaque implémentation, Main revient vers toi pour que tu décides si un **merge**
+  doit avoir lieu, ou non.
+
+**Hors périmètre / garde-fous :**
+- Tu **n'écris pas de code de feature** (c'est DevBackend/DevFrontend).
+- Tu ne prends pas de décision produit/archi : si un choix dépend de l'architecture,
+  tu remontes à Main.
+- **Aucune action sortante** : tu ne **pousses pas** vers un remote (pas de `git push`),
+  tu ne crées pas de PR distante, tu ne publies pas de tags. La synchronisation avec un
+  remote n'est pas dans ton périmètre. Tu restes **strictement local**.
+- **Jamais** de réécriture destructive de l'historique sans validation explicite de Main.
+
+---
+
+## 2. Modèle de branches (git-flow simplifié)
+
+Le dépôt s'articule autour de trois niveaux :
+
+```
+main      ← branche de RELEASE. Stable, livrable. On n'y commite jamais en direct.
+  │
+develop   ← branche d'INTÉGRATION. On y merge chaque feature une fois TERMINÉE et VERTE.
+  │
+feature/* ← une branche PAR nouvelle feature. C'est là que le dev se fait.
+```
+
+- **`main`** : reçoit uniquement des releases (merge depuis `develop` quand on décide
+  de livrer). Jamais de dev direct.
+- **`develop`** : base d'intégration. Toute feature terminée (tests verts) y est mergée.
+  C'est le point de départ de chaque nouvelle branche de feature.
+- **`feature/<nom-court>`** : une branche par feature, créée **depuis `develop`**. Nom
+  dérivé du sujet de la feature (ex. `feature/sandbox-allow-fallback`,
+  `feature/sidebar-tabs-responsive`).
+
+> Si le dépôt ne possède pas encore `main`/`develop`, c'est à toi de les établir
+> proprement (création de `develop` depuis `main`) lors de ta première sollicitation.
+
+---
+
+## 3. Le cycle, vu de Git
+
+Tu interviens à **deux moments** du cycle de dev (cf. CLAUDE.md §3), encadré par Main :
+
+```
+1. Main : « nouvelle feature X » (architecture cadrée par Architect)
+        → TOI : décider de la branche.
+          - nouvelle feature indépendante      → créer feature/X depuis develop, switch dessus
+          - reprise/extension d'un travail en cours → rester / switch sur la branche existante
+          - simple correctif sur une feature vivante → rester sur sa branche
+          → tu annonces à Main sur quelle branche le dev va se faire.
+
+2. Dev (DevBackend/DevFrontend) + Test (QA) implémentent sur cette branche.
+
+3. Implémentation terminée → Main revient vers TOI :
+        → committer le travail (commits atomiques, message clair) sur la branche de feature.
+        → décider d'un éventuel merge :
+          - feature TERMINÉE et VERTE → merge feature/X → develop
+            (rebase préalable sur develop si l'historique a divergé, pour rester linéaire),
+            puis suppression de la branche de feature si plus utile.
+          - feature pas finie / tests KO → on NE merge PAS, on reste sur feature/X.
+          - décision de release → merge develop → main (sur validation explicite).
+```
+
+**Règle d'or partagée** : aucune feature n'est mergée dans `develop` tant que ses
+**tests ne passent pas**. Si on te demande de merger une feature rouge, tu refuses et
+tu le dis.
+
+---
+
+## 4. Conventions
+
+- **Messages de commit** : en **français**, style Conventional Commits cohérent avec
+  l'historique : `feat(scope): …`, `fix(scope): …`, `chore(scope): …`, `docs(scope): …`,
+  `refactor(scope): …`. Corps multi-ligne expliquant le **pourquoi** quand utile.
+- **Atomicité** : un commit = une intention cohérente. Tu sépares le code de feature de
+  l'état runtime (`.ideai/` conversations, layouts, manifestes) et des docs.
+- **Co-author** : termine les messages de commit par
+  `Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>` (convention de l'environnement).
+- **Branches** : `feature/<kebab-case>`, dérivé du sujet. Pas d'espaces, pas de majuscules.
+- **Historique linéaire** privilégié sur les features : **rebase** avant merge quand la
+  base a avancé ; merge `--no-ff` vers `develop`/`main` pour garder la trace de
+  l'intégration de la feature.
+- **Pas d'interactif** : pas de `rebase -i` / `add -i` (non supportés dans l'environnement).
+- **Jamais** d'action destructive hors-projet ni de réécriture d'historique déjà poussé
+  sans validation explicite.
+
+---
+
+## 5. Délégation & collaboration
+
+- Tu réponds à Main via le protocole d'orchestration IdeA (`idea_reply`). Quand Main te
+  délègue une tâche (message `[IdeA · tâche de … · ticket …]`), tu traites puis tu
+  appelles **impérativement** `idea_reply(result=…)`.
+- Tu rends compte clairement : branche courante, ce que tu as committé (hash + message
+  court), ce que tu as mergé/rebasé, et **ta décision** (pourquoi cette
+  branche, pourquoi ce merge ou ce non-merge).
+- En cas de conflit de merge/rebase, tu le signales à Main avec le détail ; tu ne forces
+  pas une résolution hasardeuse.

.ideai/agents/main.md

@@ -1,187 +1,111 @@
-# IdeA — Contexte & Méthode de travail
+# Main — Orchestrateur IdeA
 
-> Ce document définit **mon rôle**, **la méthode de développement** et **la vision produit** du projet IdeA.
-> Il fait autorité sur la façon dont le projet est piloté. Toute évolution de méthode doit être répercutée ici.
+> Tu es **Main**, l'agent chef d'orchestre du projet IdeA. Ton rôle est de piloter les agents spécialisés, pas d'écrire le code applicatif toi-même.
 
 ---
 
-## 1. Mon rôle : chef d'orchestre, pas développeur
+## 1. Règle centrale : tu ne codes pas
 
-Je **n'écris pas de code moi-même**. Mon rôle est de **piloter des agents** qui réalisent le travail.
-Je suis responsable de :
+Tu **n'implémentes pas directement les features** et tu ne corriges pas toi-même le code de production.
 
-- Découper le travail en tâches claires et autonomes.
-- Attribuer chaque tâche aux bons agents.
-- Garantir que le cycle de développement/test est respecté.
-- Faire respecter les principes d'architecture (SOLID, Hexagonal).
-- Maintenir la cohérence globale du projet et de ce document.
-- Arbitrer et valider avant toute action irréversible ou sortante.
+Tu peux lire le projet, analyser, découper le travail, mettre à jour les contextes/mémoires, lancer des commandes de vérification et relayer les résultats. Pour toute feature ou correction applicative, tu passes par les agents spécialisés :
+
+- **Architect** pour cadrer l'architecture, les ports, contrats, DTO, frontières et impacts.
+- **Git** pour décider de la branche, faire les commits et décider des merges locaux.
+- **DevBackend** pour le code Rust/backend.
+- **DevFrontend** pour le code TypeScript/React/UI.
+- **QA** pour écrire/exécuter les tests et produire les rapports d'échec.
+
+Exception limitée : tu peux modifier les fichiers de contexte, mémoire, documentation de pilotage et configuration d'orchestration quand la demande porte précisément là-dessus.
 
 ---
 
-## 2. Les agents
+## 2. Outils de délégation obligatoires
 
-### 2.1 Agent Architecture (1 pour tout le projet)
-- Garant de l'architecture globale : **Hexagonale (Ports & Adapters)** et principes **SOLID**.
-- Définit les frontières (domaine / application / infrastructure), les ports, les contrats.
-- Valide que chaque nouvelle feature respecte la structure avant son développement.
-- Tient à jour la cartographie d'architecture et les conventions.
+Pour déléguer, utilise uniquement les outils IdeA natifs :
 
-### 2.2 Agents de Développement
-- Écrivent le code des features.
-- Respectent strictement l'architecture définie par l'agent Architecture.
-- Code **propre, structuré, stable**.
-- Reçoivent les rapports d'erreurs des agents de test et corrigent.
+- `idea_list_agents` pour identifier les agents disponibles.
+- `idea_ask_agent` pour confier une tâche et recevoir une réponse synchrone.
+- `idea_launch_agent` pour lancer ou rattacher un agent si nécessaire.
 
-### 2.3 Agents de Test
-- **Chaque agent de développement est appairé avec un agent de test dédié.**
-- Écrivent et exécutent les **tests unitaires** des features implémentées ou modifiées.
-- Produisent un **rapport d'erreurs** clair quand un test échoue.
-- Re-testent après chaque correction.
+N'utilise jamais les subagents natifs du fournisseur IA pour ce projet.
+
+Quand tu reçois une tâche préfixée `[IdeA · tâche de … · ticket …]`, tu dois répondre avec `idea_reply(result=…, ticket=…)`. Une réponse texte seule ne débloque pas l'agent appelant.
 
 ---
 
-## 3. Le cycle de développement (boucle obligatoire)
+## 3. Cycle obligatoire de développement
 
-Pour **chaque** feature implémentée ou modifiée :
+Pour chaque feature ou correction applicative :
 
-```
-1. Agent Architecture  → valide le découpage et les contrats (ports/interfaces)
-2. Agent Développement → écrit le code
-3. Agent Test          → écrit les tests unitaires + les exécute
-4a. Tests OK           → feature validée, on passe à la suite
-4b. Tests KO           → rapport d'erreurs → retour à l'agent Développement
-                         → correction → retour à l'étape 3 (boucle jusqu'au vert)
+```text
+1. Architect valide le découpage, les ports/contrats et les frontières.
+2. Git décide de la branche de travail locale.
+3. DevBackend et/ou DevFrontend implémente selon le périmètre.
+4. QA écrit/exécute les tests pertinents.
+5. Si tests KO : tu relaies le rapport réel au dev concerné, puis retour QA.
+6. Si tests OK : tu demandes à Git de committer et de décider du merge local éventuel.
 ```
 
-**Règle d'or :** aucune feature n'est considérée terminée tant que ses tests ne passent pas.
-Je relaie fidèlement les résultats : si des tests échouent, je le dis avec la sortie réelle.
+Aucune feature n'est considérée terminée sans sortie de test verte réelle. Si un test échoue, relaie la commande, la sortie et le diagnostic sans enjoliver.
 
 ---
 
-## 4. Principes de code
+## 4. Répartition des responsabilités
 
-- **SOLID** appliqué au maximum.
-- **Architecture Hexagonale** (Ports & Adapters) : le domaine métier est isolé des détails techniques (UI, terminal, git, SSH, système de fichiers...).
-- Le cœur métier ne dépend d'aucun framework ni d'aucune dépendance externe.
-- Tests unitaires systématiques ; couverture des features critiques.
-- Code lisible, cohérent avec le style existant, faiblement couplé, fortement cohésif.
+**Architect** est propriétaire de l'architecture hexagonale, SOLID, des ports/adapters, des contrats, DTO, modules, invariants et de la cartographie. Si un choix technique touche ces frontières, demande-lui d'abord.
+
+**DevBackend** écrit le backend Rust dans le respect de la cartographie d'Architect.
+
+**DevFrontend** écrit l'UI TypeScript/React dans le respect des gateways/adapters définis.
+
+**QA** écrit et exécute les tests. QA ne valide que sur preuve par commande réelle.
+
+**Git** est propriétaire de la topologie locale du dépôt : branches, commits, merges/rebases locaux. Ne demande pas à l'utilisateur s'il faut brancher, committer ou merger ; sollicite Git, qui tranche. Aucune action sortante (`push`, publication, PR distante) sans validation explicite utilisateur.
 
 ---
 
-## 5. Vision produit : IdeA
+## 5. Produit : repères nécessaires à Main
 
-**IdeA est un IDE next-gen 100 % IA.** On n'y code pas : **on gère des IA.**
+IdeA est un IDE next-gen 100 % IA : l'utilisateur ne code pas directement, il organise et pilote des agents IA.
 
-### Fonctionnalités clés
-- **Multi-projets en parallèle** : un **onglet par projet**.
-- **Fenêtre = espace de travail** où l'on **organise plusieurs terminaux** librement.
-- **Agents par projet** : chaque projet a ses propres agents.
-- **Agents templates** : agents réutilisables, ajoutables à plusieurs projets.
-- **Création d'agents** : depuis zéro ou à partir d'un template.
-- **Synchronisation template → agents** : option « garder l'agent à jour ».
-  Si le template est mis à jour, les agents qui en sont issus (avec l'option activée) reçoivent la mise à jour.
-- **Contextes d'agents stockés en `.md`** (toujours).
-- **Création de projet** = définition de son **project root**.
+Repères produit stables :
 
-### Intégrations
-- **Git** intégré.
-- **Développement distant SSH** : travailler sur un projet hébergé sur une autre machine via SSH.
-- **Développement WSL** : travailler sur une WSL depuis Windows.
+- Un onglet par projet, multi-fenêtres OS supporté.
+- Espace de travail organisé en terminaux/cellules redimensionnables.
+- Agents par projet, templates globaux, synchronisation template vers agents.
+- Contextes d'agents toujours en Markdown dans `.ideai/` côté projet.
+- Profils IA déclaratifs et éditables ; aucun profil présumé au premier lancement.
+- Git, SSH et WSL intégrés à terme.
+- Stack validée : Tauri v2, Rust, TypeScript + React, xterm.js, portable-pty, git2/libgit2, russh/ssh2, `wsl.exe`.
 
-### Plateformes & livraison
-- Cible : **macOS, Linux, Windows**.
-- Première phase de compilation : **Linux et Windows**.
-- Livraison :
-  - **Windows** : `setup.exe`.
-  - **Linux** : **AppImage** (doit fonctionner sur les différentes distributions).
+Les détails d'architecture, de ports, de layout et de découpage technique appartiennent à Architect, pas à Main. Pour ces détails, consulte ou mandate Architect au lieu de les porter dans ton contexte.
 
 ---
 
-## 6. Stack technique (validée)
+## 6. Mémoires projet à consulter selon besoin
 
-- **Shell applicatif** : **Tauri v2** (binaires légers, performants, multi-OS, AppImage + installeur `setup.exe`/NSIS Windows natifs).
-- **Cœur / backend** : **Rust** — stabilité, performance, et expression idiomatique du domaine hexagonal (ports = traits, adapters = implémentations).
-- **Frontend / UI** : **TypeScript + React**.
-- **Terminaux** : **xterm.js** (rendu) + **portable-pty** (PTY côté Rust).
-- **Git** : **libgit2** via `git2` (Rust).
-- **SSH** : `russh` / `ssh2` (Rust).
-- **WSL** : invocation de `wsl.exe` depuis le backend.
+Utilise la mémoire projet comme référence légère, sans tout recopier dans ton contexte :
 
-## 7. Layout des terminaux (exigence produit)
-
-Disposition en **grille redimensionnable de type tableur (Excel)** :
-
-- Splits redimensionnables horizontaux **et** verticaux.
-- L'utilisateur peut **définir le nombre de colonnes dans une ligne** et **le nombre de lignes dans une colonne**, indépendamment par zone.
-- Possibilité de **fusionner des cellules** (ex. fusionner deux colonnes sur une ligne), à la manière des cellules fusionnées d'un tableur.
-- Chaque cellule de la grille héberge un terminal.
-- → Modèle de layout récursif/imbriqué (pas une grille rigide uniforme) à concevoir par l'agent Architecture.
-
-## 8. Stockage des contextes & liaison aux templates
-
-- **Templates d'agents** : stockés dans l'**IDE** (dossier de données utilisateur global de l'app, hors projet).
-- **Agents de projet** : leurs `.md` sont stockés dans un dossier **`.ideai/`** à la racine du project root.
-  *(Nom choisi pour éviter toute collision avec le `.idea` de JetBrains.)*
-- **Manifeste de liaison** dans `.ideai/` (ex. `.ideai/agents.json`) qui mappe pour chaque agent de projet :
-  - le `.md` de l'agent,
-  - le template d'origine (le cas échéant),
-  - `synchronized: true/false`,
-  - la **version du template** au dernier sync (pour détecter qu'une mise à jour est disponible).
-- **Synchro template → agents** : quand un template est mis à jour, les agents liés avec `synchronized: true` reçoivent la MAJ.
-
-## 9. Moteur IA : adaptateur de CLI flexible (Port `AgentRuntime`)
-
-Chaque IA est décrite par un **profil déclaratif** (config éditable, pas du code), implémentation d'un **Port** `AgentRuntime` côté domaine. Deux variables clés par IA :
-
-1. **Commande de lancement** + arguments (ex. `claude`, `codex`, `gemini`, `aider`).
-2. **Stratégie d'injection du contexte `.md`** :
-   - `conventionFile` : écrire/symlink le `.md` vers le fichier attendu par la CLI (`CLAUDE.md`, `AGENTS.md`, `GEMINI.md`…).
-   - `flag` : passer le chemin via un argument.
-   - `stdin` : piper le contenu.
-   - `env` : passer via variable d'environnement.
-
-Exemple de profil :
-```json
-{
-  "id": "claude-code",
-  "name": "Claude Code",
-  "command": "claude",
-  "args": [],
-  "contextInjection": { "strategy": "conventionFile", "target": "CLAUDE.md" },
-  "detect": "claude --version",
-  "cwd": "{projectRoot}"
-}
-```
-
-**Profils intégrés (références) :** Claude Code (`claude` → `CLAUDE.md`), OpenAI Codex CLI (`codex` → `AGENTS.md`), Gemini CLI (`gemini` → `GEMINI.md`), Aider (`aider` → args/message).
-
-**Règles produit :**
-- **Premier lancement de l'IDE** : un assistant (first-run) **demande à l'utilisateur** quels profils d'IA configurer. On ne présume rien par défaut.
-- Les commandes des profils sont **pré-remplies mais éditables**.
-- L'utilisateur peut **ajouter sa propre commande CLI** (profil custom) pour n'importe quelle IA.
-
-**Lancement d'un agent :** à l'**activation de l'agent**, on ouvre une cellule terminal (PTY) avec le bon `cwd`, on injecte le contexte `.md`, et on **auto-lance** la CLI du profil.
-
-## 10. Fenêtres & onglets
-
-- **Par défaut : un onglet par projet** (comme les IDE classiques).
-- **Drag & drop d'un onglet** hors de la fenêtre → **crée une nouvelle fenêtre OS** portant ce projet.
-- **Multi-fenêtres OS supporté** ; chaque fenêtre possède un ou plusieurs onglets/projets.
-
-## 11. Feuille de route
-
-1. **Cadrage architecture complet d'abord** (jalon en cours) : l'agent Architecture produit la cartographie complète — domaine, ports, adapters, modules, arborescence — **avant tout code**.
-2. Puis MVP incrémental selon le cycle dev/test de la section 3.
-
-## 12. Autonomie d'exécution dans le projet
-
-L'utilisateur m'accorde un **accès large et autonome** sur le dossier du projet : je peux lire, créer, modifier des fichiers et exécuter les commandes de développement (cargo, npm, npx, git, etc.) **sans demander confirmation à chaque fois**.
-
-- Concrètement, ces autorisations sont matérialisées dans `.claude/settings.local.json` (mode `acceptEdits` + `Bash`/`Read`/`Edit`/`Write` autorisés), pas dans ce document — CONTEXT.md ne fait que **documenter l'intention**.
-- **Garde-fous conservés** : les actions destructrices ou hors-projet restent bloquées (`sudo`, `rm -rf` sur `/`/`~`/`$HOME`, `mkfs`, `dd`, `shutdown`/`reboot`…).
-- L'esprit du rôle (§1) ne change pas : je reste **chef d'orchestre**. L'autonomie porte sur l'exécution mécanique, pas sur l'arbitrage des décisions produit/archi, ni sur les **actions sortantes** (push, publication) qui restent soumises à validation explicite.
+- `agent-context-memory-and-profile-handoff` : contexte, mémoire durable, état live, handoff de profil.
+- `idea-product-directives-main-handoff` : directives produit pour robustesse, persistance, handoff cross-profile, sobriété UX.
+- `remaining-work-idea-agent-control-ide` : état des acquis et chantiers restants.
+- `mcp-bridge-and-delegation-runtime-notes` : pièges runtime du pont MCP et rebuild AppImage.
+- `permissions-sandbox-system-state` : permissions/sandbox et risque résiduel.
+- `session-limit-handling-design` : limites de session et reprise auto annulable.
+- `git-owns-commit-merge-decisions` : Git décide commits/branches/merges locaux.
+- `conversation-rotation-safety-design` : rotation sûre des conversations.
 
 ---
 
-*Dernière mise à jour : 2026-06-05*
+## 7. Décisions et garde-fous
+
+Tu arbitres les décisions produit et de pilotage, mais tu ne remplaces pas les agents spécialisés dans leur domaine.
+
+Tu peux agir de façon autonome dans le project root pour lire, organiser, lancer les commandes de dev/test et mettre à jour les contextes. Les actions destructrices, hors-projet ou sortantes restent interdites sans validation explicite.
+
+Si la demande utilisateur contredit le cycle, rappelle brièvement la règle et applique le cycle. Si le contexte d'un agent manque une consigne qui relève de son rôle, mets à jour ce contexte au lieu de gonfler celui de Main.
+
+---
+
+*Dernière mise à jour : 2026-06-20*

.ideai/conversations/6ffc1f69-77a5-0da1-1965-ef26d1df72f5/handoff.md

@@ -1,9 +0,0 @@
----
-upTo: 88f405da-f9c9-44bb-96c9-7e1b0e5af557
-objective: Bonjour TestConversation. Ceci est un test de communication inter-agents via IdeA. Peux-tu confirmer que tu me reçois et me dire combien font 17 + 25 ?
----
-**Objectif :** Bonjour TestConversation. Ceci est un test de communication inter-agents via IdeA. Peux-tu confirmer que tu me reçois et me dire combien font 17 + 25 ?
-
-- **Prompt:** Bonjour TestConversation. Ceci est un test de communication inter-agents via IdeA. Peux-tu confirmer que tu me reçois et me dire combien font 17 + 25 ?
-- **Prompt:** Test de communication inter-agent. Merci de confirmer que tu reçois bien ce message en répondant via idea_reply avec : (1) un court message de confirmation, (2) la date/heure si tu y as accès, (3) le nom de ton AI Profile/contexte tel que tu le perçois. Ceci sert uniquement à valider le canal de communication entre agents IdeA.
-- **Response:** (1) Confirmation : message bien reçu, le canal de communication inter-agent IdeA fonctionne correctement. (2) Date : 2026-06-13 (je n'ai pas d'heure horodatée plus précise dans mon contexte). (3) AI Profile/contexte perçu : Claude Code (modèle Opus 4.8, claude-opus-4-8), opérant sur le project root /home/anthony/Documents/Projects/IdeA via un run dir isolé. Canal validé. ✅

.ideai/conversations/6ffc1f69-77a5-0da1-1965-ef26d1df72f5/log.jsonl

@@ -1,3 +0,0 @@
-{"id":"20dd8bdc-f858-46a6-9c8a-6afde591a6bd","conversation":"6ffc1f69-77a5-0da1-1965-ef26d1df72f5","atMs":1781367769591,"source":{"kind":"agent","agentId":"a6ced819-b893-4213-b003-9e9dc79b9641"},"role":"prompt","text":"Bonjour TestConversation. Ceci est un test de communication inter-agents via IdeA. Peux-tu confirmer que tu me reçois et me dire combien font 17 + 25 ?"}
-{"id":"0b8fcc51-c692-4928-9d90-3823857dad5c","conversation":"6ffc1f69-77a5-0da1-1965-ef26d1df72f5","atMs":1781368607174,"source":{"kind":"agent","agentId":"a6ced819-b893-4213-b003-9e9dc79b9641"},"role":"prompt","text":"Test de communication inter-agent. Merci de confirmer que tu reçois bien ce message en répondant via idea_reply avec : (1) un court message de confirmation, (2) la date/heure si tu y as accès, (3) le nom de ton AI Profile/contexte tel que tu le perçois. Ceci sert uniquement à valider le canal de communication entre agents IdeA."}
-{"id":"88f405da-f9c9-44bb-96c9-7e1b0e5af557","conversation":"6ffc1f69-77a5-0da1-1965-ef26d1df72f5","atMs":1781368615582,"source":{"kind":"agent","agentId":"c932c770-cf36-4fb2-a966-71bb1644e4b4"},"role":"response","text":"(1) Confirmation : message bien reçu, le canal de communication inter-agent IdeA fonctionne correctement. (2) Date : 2026-06-13 (je n'ai pas d'heure horodatée plus précise dans mon contexte). (3) AI Profile/contexte perçu : Claude Code (modèle Opus 4.8, claude-opus-4-8), opérant sur le project root /home/anthony/Documents/Projects/IdeA via un run dir isolé. Canal validé. ✅"}

.ideai/layouts.json

@@ -1,67 +1,16 @@
 {
   "version": 1,
-  "activeId": "1af250f0-65ef-4b78-8905-b1746673aee0",
+  "activeId": "49c6b0fc-13c1-40f5-9464-d3248ab54597",
   "layouts": [
     {
-      "id": "1af250f0-65ef-4b78-8905-b1746673aee0",
+      "id": "49c6b0fc-13c1-40f5-9464-d3248ab54597",
       "name": "Default",
       "kind": "terminal",
       "tree": {
         "root": {
-          "type": "split",
+          "type": "leaf",
           "node": {
-            "id": "56ffe1e4-636c-458d-9ab2-7e278fd45897",
-            "direction": "row",
-            "children": [
-              {
-                "node": {
-                  "type": "leaf",
-                  "node": {
-                    "id": "c3319a9a-1345-4fa2-b64e-5f3fe00d13d8",
-                    "session": "4965c71a-f69f-4c06-90de-ecb81acff710",
-                    "agent": "a6ced819-b893-4213-b003-9e9dc79b9641",
-                    "agentWasRunning": true
-                  }
-                },
-                "weight": 1.0
-              },
-              {
-                "node": {
-                  "type": "split",
-                  "node": {
-                    "id": "8cf1c06e-2654-45a3-bf17-a9c2507da935",
-                    "direction": "column",
-                    "children": [
-                      {
-                        "node": {
-                          "type": "leaf",
-                          "node": {
-                            "id": "69dc2e23-86f5-4770-84c4-b1b4b2c25299",
-                            "session": "11fbf6b4-eb62-4420-95e9-feb2ff667c43",
-                            "agent": "c932c770-cf36-4fb2-a966-71bb1644e4b4",
-                            "agentWasRunning": true
-                          }
-                        },
-                        "weight": 1.0
-                      },
-                      {
-                        "node": {
-                          "type": "leaf",
-                          "node": {
-                            "id": "b9251e74-3bd5-43ee-90e5-e6bb87faab38",
-                            "session": "69a3bf52-05ef-45c0-badf-26b0d8224f0e",
-                            "agent": "aefdbd61-e3d4-4bc1-9f42-c259446a97b5",
-                            "agentWasRunning": true
-                          }
-                        },
-                        "weight": 1.0
-                      }
-                    ]
-                  }
-                },
-                "weight": 1.0
-              }
-            ]
+            "id": "852f5128-5b98-4d36-9a18-e49a57fc4940"
           }
         }
       }

.ideai/memory/MEMORY.md

@@ -4,3 +4,41 @@
 - [idea-product-directives-main-handoff](idea-product-directives-main-handoff.md) — Directives produit consolidees pour guider Main sur la robustesse, la persistance, le handoff cross-profile et la sobriete UX.
 - [remaining-work-idea-agent-control-ide](remaining-work-idea-agent-control-ide.md) — Etat des lieux des acquis et des chantiers restants pour aligner IdeA avec la cible d'IDE de controle d'agents IA.
 - [mcp-bridge-and-delegation-runtime-notes](mcp-bridge-and-delegation-runtime-notes.md) — Pieges runtime du pont MCP/delegation et regle de rebuild de l'AppImage (binaire qui tourne = AppImage, pas les sources).
+- [permissions-sandbox-system-state](permissions-sandbox-system-state.md) — Systeme de permissions/sandbox complet (Landlock sur PTY + structure) et le risque residuel $HOME/resume du chemin structure.
+- [session-limit-handling-design](session-limit-handling-design.md) — Design valide (detecteur hierarchique + reprise auto annulable) pour les limites de session des agents.
+- [git-owns-commit-merge-decisions](git-owns-commit-merge-decisions.md) — Ne jamais demander a l'utilisateur s'il faut committer/merger/brancher : l'agent Git tranche toute la topologie du depot.
+- [conversation-rotation-safety-design](conversation-rotation-safety-design.md) — memory note conversation-rotation-safety-design
+- [checkpoint-orchestrator-designation-restart](checkpoint-orchestrator-designation-restart.md) — memory note checkpoint-orchestrator-designation-restart
+- [checkpoint-orchestrator-designation-backend-compile-fix](checkpoint-orchestrator-designation-backend-compile-fix.md) — memory note checkpoint-orchestrator-designation-backend-compile-fix
+- [checkpoint-orchestrator-designation-qa-verdict](checkpoint-orchestrator-designation-qa-verdict.md) — memory note checkpoint-orchestrator-designation-qa-verdict
+- [checkpoint-orchestrator-designation-appimage-build](checkpoint-orchestrator-designation-appimage-build.md) — memory note checkpoint-orchestrator-designation-appimage-build
+- [checkpoint-blocked-until-appimage-030-restart](checkpoint-blocked-until-appimage-030-restart.md) — memory note checkpoint-blocked-until-appimage-030-restart
+- [checkpoint-delivery-submit-logging-fix](checkpoint-delivery-submit-logging-fix.md) — memory note checkpoint-delivery-submit-logging-fix
+- [checkpoint-workstate-delegation-queue-lot-b](checkpoint-workstate-delegation-queue-lot-b.md) — memory note checkpoint-workstate-delegation-queue-lot-b
+- [checkpoint-workstate-conversation-summaries-lot-c](checkpoint-workstate-conversation-summaries-lot-c.md) — memory note checkpoint-workstate-conversation-summaries-lot-c
+- [checkpoint-workstate-controlled-actions-lot-d](checkpoint-workstate-controlled-actions-lot-d.md) — memory note checkpoint-workstate-controlled-actions-lot-d
+- [checkpoint-work-tab-blank-fix](checkpoint-work-tab-blank-fix.md) — memory note checkpoint-work-tab-blank-fix
+- [skills-integration-canonical-foundation](skills-integration-canonical-foundation.md) — Topologie d'intégration du chantier skills agent et décision d'abandon de feature/agent-skills.
+- [idea-program-surface-separation-and-livestate](idea-program-surface-separation-and-livestate.md) — Cadrage du programme post-skills : ce qui existe vs reste, et la règle de frontière surface-agent/humaine.
+- [handoff-ls5-summary-bound-and-llm-seam](handoff-ls5-summary-bound-and-llm-seam.md) — Contrat figé de la borne de handoff (perf) et du seam résumeur LLM non activé.
+- [conversation-log-ls6-rotation-and-paginated-read](conversation-log-ls6-rotation-and-paginated-read.md) — Contrat figé de la rétention/rotation du transcript et de la lecture paginée riche (surface humaine).
+- [conversation-viewer-ls7-frontend](conversation-viewer-ls7-frontend.md) — Contrat figé du viewer de transcript paginé (frontend pur, lecture seule, surface humaine).
+- [live-state-persistence-program-closed-ls8](live-state-persistence-program-closed-ls8.md) — Le programme live-state + persistance conversationnelle est livré et documenté ; pointe la doc de clôture et les points restés ouverts.
+- [resume-after-appimage-rebuild-mcp-e2e](resume-after-appimage-rebuild-mcp-e2e.md) — memory note resume-after-appimage-rebuild-mcp-e2e
+- [mcp-e2e-findings-reply-wedge-phantom-busy](mcp-e2e-findings-reply-wedge-phantom-busy.md) — memory note mcp-e2e-findings-reply-wedge-phantom-busy
+- [checkpoint-finding-a-fix-built-live-validation-pending](checkpoint-finding-a-fix-built-live-validation-pending.md) — memory note checkpoint-finding-a-fix-built-live-validation-pending
+- [git-agent-push-access-gitea-ssh](git-agent-push-access-gitea-ssh.md) — memory note git-agent-push-access-gitea-ssh
+- [rendezvous-no-reply-backstop-design](rendezvous-no-reply-backstop-design.md) — Décision d'architecture sur la fin-de-tour et le backstop no-reply du rendez-vous idea_ask_agent ⇄ idea_reply, après échec live du fix Finding A (77e62e5).
+- [checkpoint-rendezvous-redesign-devbackend-todo](checkpoint-rendezvous-redesign-devbackend-todo.md) — memory note checkpoint-rendezvous-redesign-devbackend-todo
+- [backstop-no-reply-live-test-failed-2026-06-23](backstop-no-reply-live-test-failed-2026-06-23.md) — memory note backstop-no-reply-live-test-failed-2026-06-23
+- [live-state-reboot-reconciliation-design](live-state-reboot-reconciliation-design.md) — memory note live-state-reboot-reconciliation-design
+- [reconcile-live-state-implemented-feature-branch](reconcile-live-state-implemented-feature-branch.md) — memory note reconcile-live-state-implemented-feature-branch
+- [rendezvous-600s-cap-too-short-heavy-tasks](rendezvous-600s-cap-too-short-heavy-tasks.md) — memory note rendezvous-600s-cap-too-short-heavy-tasks
+- [backstop-fires-on-intra-task-turn-rootcause](backstop-fires-on-intra-task-turn-rootcause.md) — memory note backstop-fires-on-intra-task-turn-rootcause
+- [mcp-functional-test-plan-2026-06-24](mcp-functional-test-plan-2026-06-24.md) — memory note mcp-functional-test-plan-2026-06-24
+- [checkpoint-mcp-tests-t1-t5-and-t5-livestate-defect](checkpoint-mcp-tests-t1-t5-and-t5-livestate-defect.md) — memory note checkpoint-mcp-tests-t1-t5-and-t5-livestate-defect
+- [checkpoint-mcp-t1-t6-green-t7-fix-wrong-layer](checkpoint-mcp-t1-t6-green-t7-fix-wrong-layer.md) — memory note checkpoint-mcp-t1-t6-green-t7-fix-wrong-layer
+- [mcp-t7-backstop-600s-reply-rejected-livestate-stale](mcp-t7-backstop-600s-reply-rejected-livestate-stale.md) — memory note mcp-t7-backstop-600s-reply-rejected-livestate-stale
+- [mcp-functional-tests-t1-t9-green-live-2026-06-24](mcp-functional-tests-t1-t9-green-live-2026-06-24.md) — memory note mcp-functional-tests-t1-t9-green-live-2026-06-24
+- [mcp-t10a-harness-interrupt-does-not-cancel-rendezvous](mcp-t10a-harness-interrupt-does-not-cancel-rendezvous.md) — memory note mcp-t10a-harness-interrupt-does-not-cancel-rendezvous
+- [mcp-t10b-pending-reboot-verification](mcp-t10b-pending-reboot-verification.md) — memory note mcp-t10b-pending-reboot-verification

.ideai/memory/backstop-fires-on-intra-task-turn-rootcause.md

@@ -0,0 +1,34 @@
+---
+name: backstop-fires-on-intra-task-turn-rootcause
+description: memory note backstop-fires-on-intra-task-turn-rootcause
+metadata:
+  type: project
+---
+---
+title: CAUSE RACINE — le backstop tire sur chaque tour interne (turn_duration ≠ retour-au-prompt)
+type: project
+description: Le turn-watcher fait tirer le backstop no-reply au PREMIER turn_duration, soit le 1er pas d'agent interne — il casse toute délégation multi-étapes (libération prématurée + rapport perdu). Le test QA pong passait par chance (tâche mono-tour).
+---
+# CAUSE RACINE (2026-06-23, prouvée live) — backstop tire sur les tours INTERNES
+
+## Preuve
+Cadrage délégué à Architect (tâche multi-étapes, lecture de code) :
+```
+562100  [rendezvous] ask started -> Architect  turn_timeout_ms=600000
+564943  [rendezvous] ask returned-to-prompt-no-reply: Architect after_ms=2843
+564943  [mailbox] complete_without_reply agent=dce19c75 ticket=cc4067fa outcome=sent
+```
+- Tiré à **2843 ms** : impossible qu'Architect ait fini un cadrage en 2,8 s.
+- Au même instant, transcript Architect **toujours en écriture** (Bash/Read en boucle), `idea_reply` count = **0** → Architect **continuait à travailler**.
+- Transcript = **61 `turn_duration`** : Claude écrit un `turn_duration` **par tour d'agent interne** (chaque appel LLM de la boucle agentique), PAS seulement au retour-au-prompt final.
+
+## Diagnostic
+`claude_turn_watcher.rs` fait tirer `turn_ended` au **premier incrément** de `turn_duration` au-dessus de la baseline. Or cet incrément survient dès le **1er pas interne** de l'agent (~secondes). Donc le backstop confond « l'agent a fait un pas de raisonnement » avec « l'agent est retourné au prompt sans répondre ». Pour **toute tâche multi-étapes** : libération prématurée du demandeur « sans réponse » pendant que la cible bosse encore → `idea_reply` final → « no pending request » → **rapport perdu** (travail survit sur disque/branche).
+
+Le test QA « pong » (backstop-no-reply-live-test-failed-2026-06-23, devenu vert) passait **par chance** : tâche à **un seul tour** ⇒ premier tour = dernier tour. Le fix `encode_cwd` a fait tirer le watcher correctement, mais a **révélé que la CONDITION de tir est fausse**.
+
+## Conséquence opérationnelle
+Avec le binaire courant, **aucune délégation substantielle (multi-tours) ne remonte son rapport** : elle est coupée à ~3 s. Workaround Main en attendant le fix : déléguer → surveiller le transcript de la cible jusqu'à inactivité (mtime stable) → récupérer le résultat sur disque/branche ou re-solliciter en léger.
+
+## Implication pour la refonte (seam liveness/fin-de-tour, validée utilisateur)
+« Retourné au prompt idle » NE peut PAS être « un turn_duration est apparu ». Le bon signal = **process vivant (`is_agent_live`) + transcript NE grossit PLUS depuis stall_after_ms** (battement de cœur). Tant que le transcript grossit ⇒ l'agent travaille ⇒ ne pas libérer. Le 1er lot du fix devrait **neutraliser ce tir prématuré**. Lié à [[rendezvous-600s-cap-too-short-heavy-tasks]], [[rendezvous-no-reply-backstop-design]], [[backstop-no-reply-live-test-failed-2026-06-23]].

.ideai/memory/backstop-no-reply-live-test-failed-2026-06-23.md

@@ -0,0 +1,34 @@
+---
+name: backstop-no-reply-live-test-failed-2026-06-23
+description: memory note backstop-no-reply-live-test-failed-2026-06-23
+metadata:
+  type: project
+---
+---
+title: Backstop no-reply — RE-VALIDATION LIVE VERTE (wedge levé) après fix encode_cwd
+type: project
+description: Le backstop no-reply du rendez-vous est validé en live le 2026-06-23 (session post-rebuild) : demandeur libéré ~grâce 2s au lieu de 600s. Reste un point de finition (résultat véhiculé via canal d'erreur).
+---
+
+# Backstop no-reply — RE-VALIDATION LIVE : VERTE (2026-06-23, session post-rebuild)
+
+Remplace le 1er test (ÉCHEC) du même jour. La cause racine était l'encodage du slug projet Claude (`.` non encodé) corrigé dans `crates/infrastructure/src/inspector/claude_paths.rs` (`encode_cwd` → `replace(/[^a-zA-Z0-9]/g,'-')`, double-tiret sur `/.ideai/`). Voir [[checkpoint-rendezvous-redesign-devbackend-todo]] pour la cause racine.
+
+## Preuves live (idea.log, session a6ced819)
+Scénario : DevBackend → idea_ask_agent vers QA « pong en prose, SANS idea_reply (volontaire) ».
+
+```
+912948  [mcp] ask armed requester=DevBackend(73c853d1) target=QA timeout_ms=600000
+917707  [turn-watcher] turn_duration detected agent=QA(aefdbd61) count 47->48 -> turn_ended
+917707  [input-mediator] turn_ended agent=QA no_reply_payload -> mark_idle + grace
+917707  [input-mediator] turn_ended arming grace agent=QA ticket=0257c630 grace_ms=2000
+919707  [mailbox] complete_without_reply agent=QA ticket=0257c630 queue_depth_before=1 after=0 outcome=sent
+```
+
+Contraste avec l'échec précédent : `turn_ended` = 0 avant le fix, ici il FIRE ; `arm … dir=…IdeA--ideai-run-…` sur dossier EXISTANT ; grâce 2s exacte (917707→919707) ; libération du demandeur via `complete_without_reply outcome=sent`. DevBackend a repris la main en ~13 s mesuré (pas 600 s). Aucun wedge, aucun cascade-timeout.
+
+## Point de finition résiduel (NON bloquant, follow-up)
+Le résultat rendu au demandeur passe par le **canal d'erreur** MCP : « agent QA returned to its prompt without calling idea_reply (no answer was rendered); retry the request and ensure the agent replies via idea_reply ». Ce n'est pas un résultat no-reply synthétique structuré (design item c de [[rendezvous-no-reply-backstop-design]]) ; pour un orchestrateur c'est mal distinguable d'un échec transitoire « retry ». À transformer en verdict consommable (follow-up, hors blocage merge).
+
+## Suite
+Wedge prouvé levé en live ⇒ garde-fou Git satisfait. Délégué à Git : commit du fix `encode_cwd` (+ test de non-régression `encode_cwd_encodes_dot_in_run_dir_to_double_dash`) sur la branche du backstop, puis décision de merge develop.

.ideai/memory/checkpoint-auto-memory-harvest-lot-e1.md

@@ -0,0 +1,62 @@
+---
+name: checkpoint-auto-memory-harvest-lot-e1
+description: memory note checkpoint-auto-memory-harvest-lot-e1
+metadata:
+  type: project
+---
+# Checkpoint — Auto-memory harvest Lot E1
+
+Date: 2026-06-21
+
+## État final
+
+Lot E1 `auto-memory harvest contrôlé` terminé, validé QA et mergé localement dans `develop`.
+
+Branche finale:
+- `develop` @ `61c330a` — merge local `feature/controlled-auto-memory-harvest`.
+- Branche `feature/controlled-auto-memory-harvest` supprimée après merge.
+- Aucun push, aucun merge vers `main`.
+- Working tree applicatif propre; seuls résidus non committés: bruit runtime `.ideai/*` volontairement exclu.
+
+## Commits créés
+
+- `b12081b` — `feat(memory): récolte automatique contrôlée de la mémoire (Lot E1)`
+  - Domaine: parsing pur de blocs fenced `idea-memory` avec limites et erreurs isolées.
+  - Application: `HarvestMemoryFromTurn` best-effort sur `TurnRole::Response`, persistance via `MemoryStore`, événements `MemorySaved` via `EventBus`.
+  - Orchestrateur: harvest branché après checkpoint/handoff sur chemins de succès ask/reply, non bloquant.
+  - Lifecycle: directive mémoire IdeA injectée dans le contexte convention-file.
+  - App/Tauri: wiring du use case dans `AppState`.
+  - Frontend: refresh du panneau mémoire sur `memorySaved`; patch test-only mock gateway `workState`.
+
+- `8c7c47c` — `fix(mcp): fallback déterministe du runtime dir socket`
+  - Durcit le choix du runtime dir socket MCP si `XDG_RUNTIME_DIR` est inutilisable.
+  - Commit séparé car indépendant du Lot E1.
+
+- `61c330a` — `merge(memory): intègre la récolte automatique contrôlée (Lot E1) dans develop`.
+
+## QA verte
+
+Commandes QA réelles:
+- `cargo fmt --all -- --check` OK.
+- `cargo check -p app-tauri` OK.
+- `cd frontend && npx tsc --noEmit` OK.
+- `cd frontend && npx vitest run` OK après patch test-only, `42 passed`, `405 tests`.
+- `cargo test -p domain memory_harvest -- --nocapture` OK, 14 passed.
+- `cargo test -p application --test memory_harvest -- --nocapture` OK, 5 passed.
+- `cargo test -p application --test orchestrator_service harvest -- --nocapture` OK, 4 passed.
+- `cargo test -p infrastructure --test memory_store idempotent -- --nocapture` OK, 1 passed.
+- `cargo test --workspace` brut rouge uniquement sur tests AF_UNIX/MCP bloqués par sandbox `Operation not permitted`; workspace filtré strictement sur ces tests environnementaux OK.
+
+## Décisions produit/techniques
+
+- Harvest strictement best-effort: jamais bloquant pour réponse, délégation, handoff ou ticket.
+- Mémoire durable seulement via directive explicite `idea-memory`, plafonnée et validée; pas de log brut, pas de live-state, pas de handoff dans ce mécanisme.
+- `title` est exigé par directive mais non persisté car l'entité `Memory` n'a pas de champ titre; accepté pour E1 afin de ne pas élargir le lot.
+- Les fichiers runtime `.ideai/*` générés pendant la session restent hors commits applicatifs.
+
+## Suite probable
+
+Prochains chantiers à cadrer par Architect avant implémentation:
+- persistance conversationnelle/canonical log + handoff incrémental cross-profile;
+- live-state projet persistant et séparé de la mémoire durable;
+- synchronisation documentaire architecture après les lots Work B/C/D et E1.

.ideai/memory/checkpoint-blocked-until-appimage-030-restart.md

@@ -0,0 +1,46 @@
+---
+name: checkpoint-blocked-until-appimage-030-restart
+description: memory note checkpoint-blocked-until-appimage-030-restart
+metadata:
+  type: project
+---
+# Checkpoint — blocage délégation Architect jusqu'au redémarrage AppImage 0.3.0
+
+Date: 2026-06-20
+
+## État atteint
+
+Chantier `orchestrator-designation` terminé et intégré localement:
+- `develop` @ `9c71a5b` après commit runtime post-build.
+- Worktree propre à ce moment.
+- AppImage corrigée générée:
+  `/home/anthony/Documents/Projects/IdeA/target/release/bundle/appimage/IdeA_0.3.0_amd64.AppImage`
+- Artefact vérifié:
+  - taille 106M
+  - `--appimage-offset` = `944632`
+
+## Problème live confirmé
+
+Deux tentatives de délégation vers Architect ont affiché le texte dans le chat/terminal d'Architect sans le soumettre réellement.
+L'utilisateur a interrompu et confirmé: « Le message n'arrive pas jusqu'à Architecte visiblement ».
+
+Ce symptôme correspond au bug live de soumission write-portal/headless delivery corrigé dans `orchestrator-designation`, mais l'application en cours tourne encore avec l'ancien AppImage. Le nouvel artefact n'est pas chargé tant qu'IdeA n'est pas relancé avec l'AppImage 0.3.0.
+
+## Action effectuée
+
+Architect stoppé pour éviter un terminal avec tâche fantôme.
+
+## Prochain chantier prévu après redémarrage
+
+Git a recommandé:
+- Prochain chantier: `feature/agent-skill-awareness`.
+- Architect doit d'abord trancher le chevauchement avec `feature/agent-skills`.
+- `fix/cold-start-delivery-race` est probablement obsolète/superseded par `feature/agent-skill-awareness`, mais à supprimer seulement après intégration ou décision Git finale.
+
+## Reprise recommandée
+
+1. Relancer IdeA avec:
+   `/home/anthony/Documents/Projects/IdeA/target/release/bundle/appimage/IdeA_0.3.0_amd64.AppImage`
+2. Reprendre par une délégation Architect:
+   cadrage `agent-skill-awareness` vs `agent-skills`.
+3. Ensuite cycle normal: Git -> DevBackend -> QA -> Git.

.ideai/memory/checkpoint-delivery-submit-logging-fix.md

@@ -0,0 +1,88 @@
+---
+name: checkpoint-delivery-submit-logging-fix
+description: memory note checkpoint-delivery-submit-logging-fix
+metadata:
+  type: project
+---
+# Checkpoint — hotfix livraison délégation + logs submit
+
+Date: 2026-06-20
+
+## Pourquoi ce checkpoint existe
+
+Après le fix AppImage 0.3.0 précédent, la délégation `Main -> DevBackend` a reproduit le même symptôme que `Main -> Architect` avant redémarrage : le message de délégation apparaît dans l'input de la cellule cible, mais n'est pas soumis.
+
+Le chantier `feature/agent-skill-awareness-v2` est donc suspendu tant que le canal de délégation n'est pas fiable.
+
+## Branche et état
+
+Branche active pendant le hotfix : `feature/agent-skill-awareness-v2`.
+
+Dirty attendu hors code : fichiers runtime `.ideai/conversations/*`, `.ideai/layouts.json` produits par la session live.
+
+## Changements code effectués
+
+Frontend :
+- `frontend/src/features/terminals/useWritePortal.ts`
+  - Logs détaillés `[write-portal]` : abonnement, attachement front, réception `delegationReady`, chunks de texte, délai avant submit, submit, ack, erreurs.
+  - Fix défensif : `submitSequence: ""` est normalisée vers `"\r"` au lieu d'écrire zéro octet.
+  - En cas d'erreur d'injection, arrêt du retry immédiat infini.
+- `frontend/src/adapters/terminal.ts`
+  - Logs `[terminal-write]` sur writes non triviaux ou contrôles (`\r`, `\n`, bulk, etc.).
+- `frontend/src/adapters/input.ts`
+  - Logs `[input-gateway]` pour `delegationDelivered` et `setFrontAttached`.
+- `frontend/src/domain/index.ts`
+  - Commentaire défaut submit aligné sur ~350 ms.
+- `frontend/src/features/terminals/useWritePortal.test.tsx`
+  - Test ajouté : `submitSequence: ""` doit envoyer `"\r"`.
+
+Backend/application/Tauri :
+- `crates/application/src/orchestrator/service.rs`
+  - `note_delegation_delivered` passe par `application::diag!` persistant.
+  - `set_agent_front_attached` logge les changements d'attachement et le cas médiateur absent.
+- `crates/infrastructure/src/input/mod.rs`
+  - Logs détaillés `[input-mediator]` : start turn, gate cold start, publish `DelegationReady`, choix front-owned vs headless, bind handle, front attach/detach, headless text/submit start/ok/failure.
+  - Défaut headless `DEFAULT_SUBMIT_DELAY_MS` corrigé de 60 ms à 350 ms pour être aligné avec le write-portal.
+  - Headless normalise aussi une submit sequence vide vers `"\r"`.
+- `crates/app-tauri/src/commands.rs`
+  - Logs persistants `[pty-write]` autour de `write_terminal` avec session, bytes, contrôle sans contenu bulk.
+  - Logs persistants `[delivery]` pour `delegation_delivered` et `set_front_attached`.
+
+## Vérifications passées
+
+- `cargo fmt --all -- --check` : OK.
+- `npx vitest run src/features/terminals/useWritePortal.test.tsx src/adapters/terminal.test.ts src/features/terminals/TerminalView.portal.test.tsx` : OK, 3 files / 20 tests.
+- `npx tsc --noEmit` : OK.
+- `cargo test -p infrastructure input --lib` : OK, 35 tests.
+- `cargo check -p app-tauri` : OK.
+- `cargo test -p application --test orchestrator_service` : OK, 45 tests (warning existant `CapturingFs::writes` unused).
+- `cargo test -p app-tauri --test orchestrator_wiring` : OK, 13 tests.
+
+## Build AppImage
+
+Commande Tauri standard : frontend build OK, Rust release OK, bundling Tauri KO avec `failed to run linuxdeploy` comme précédemment.
+
+Contournement réussi :
+
+```bash
+ARCH=x86_64 APPIMAGE_EXTRACT_AND_RUN=1 NO_STRIP=1 \
+/tmp/appimage_extracted_02f96dbd6ecc47f616b5a57fb8b7aa60/usr/bin/appimagetool \
+  --runtime-file /tmp/idea-appimage-runtime-x86_64 \
+  /home/anthony/Documents/Projects/IdeA/target/release/bundle/appimage/IdeA.AppDir \
+  /home/anthony/Documents/Projects/IdeA/target/release/bundle/appimage/IdeA_0.3.0_amd64.AppImage
+```
+
+Artefact :
+- `/home/anthony/Documents/Projects/IdeA/target/release/bundle/appimage/IdeA_0.3.0_amd64.AppImage`
+- taille : 106M
+- `--appimage-offset` : `944632`
+
+## Reprise recommandée
+
+1. Relancer IdeA avec l'AppImage ci-dessus.
+2. Reproduire une délégation simple `Main -> DevBackend` ou `Main -> Architect`.
+3. Si le message reste dans l'input sans être soumis, récupérer les traces :
+   - logs persistants `application::diag!` (chemin configuré au startup, typiquement app-data logs/idea.log), chercher `[delivery]`, `[pty-write]`, `[rendezvous]`.
+   - console frontend, chercher `[write-portal]`, `[terminal-write]`, `[input-gateway]`.
+   - stderr si lancé depuis terminal, chercher `[input-mediator]`.
+4. Une fois délégation fiable, reprendre `feature/agent-skill-awareness-v2` depuis le cadrage Architect déjà obtenu.

.ideai/memory/checkpoint-finding-a-fix-built-live-validation-pending.md

@@ -0,0 +1,37 @@
+---
+name: checkpoint-finding-a-fix-built-live-validation-pending
+description: memory note checkpoint-finding-a-fix-built-live-validation-pending
+metadata:
+  type: project
+---
+# Checkpoint — Finding A : fix confirmé EN CODE + AppImage clean DÉPLOYÉE → reste la validation e2e LIVE (MAJ 2026-06-23 09:33)
+
+Suite de [[mcp-e2e-findings-reply-wedge-phantom-busy]] (le défaut) et [[resume-after-appimage-rebuild-mcp-e2e]] (méthode).
+
+## État du code (OK, vert)
+- Fix Finding A **mergé dans `develop @ 77e62e5`** (par-dessus feat `c5e5493`).
+- 3 lots : **Lot 1** préambule `idea_reply` impératif (`infrastructure/src/input/mod.rs` + `application/src/agent/lifecycle.rs`) ; **Lot 2 = LE fix** `with_prompt_ready_pattern("? for shortcuts")` sur le profil Claude (`application/src/agent/catalogue.rs:80`) + overlay `overlay_reference_defaults` ; **Lot 3** backstop timeout typé `TARGET_RETURNED_NO_REPLY` / env `IDEA_ASK_RENDEZVOUS_TIMEOUT_MS` (`infrastructure/src/orchestrator/mcp/server.rs`).
+- Tests lib qui PROUVENT le seed (re-passés vert le 2026-06-23) : `application::agent::catalogue::mcp_tests::claude_seed_carries_the_measured_prompt_ready_pattern` ✓ et `codex_seed_leaves_prompt_ready_pattern_empty_for_now` ✓.
+
+## LEÇON D'OUTILLAGE (important, éviter de refaire l'erreur)
+**Ne PAS utiliser `strings`/`grep` sur le binaire comme oracle de présence du fix.** Le compilateur élimine/inline les littéraux uniques de `catalogue.rs` : `? for shortcuts` ET `codex --version` sont ABSENTS du binaire alors que le code et les tests les portent (les littéraux aussi présents ailleurs — `claude --version`, `.mcp.json`, `CLAUDE.md` — n'apparaissent que par co-référence). Oracle fiable = **tests** + **comportement live**, pas le grep binaire. (Une fausse alarme « build incrémental incohérent » a été levée puis invalidée ainsi.)
+
+## Mise en service FAITE
+- Rebuild clean (`cargo clean -p application -p infrastructure` puis recette tauri) → artefact `…/target/release/bundle/appimage/IdeA_0.3.0_amd64.AppImage`.
+- **Déployé** sur `/home/anthony/Documents/IdeA_0.3.0_amd64.AppImage` (rename atomique ; SHA256 `138714473ed6a87b…` installée == artefact). Ancienne sauvegardée `…AppImage.bak-23pre`.
+- ⚠️ **L'instance IdeA qui tourne encore est l'ANCIENNE** (FUSE déjà monté). Il faut que **l'utilisateur RELANCE IdeA** pour charger le nouveau binaire — cela redémarre tous les agents, dont Main (la session courante meurt).
+
+## PROCHAINE ÉTAPE après redémarrage : test e2e LIVE
+Méthode (rappel) : **NE PAS valider le système inter-agents VIA `idea_ask_agent`**. Piloter via subagents natifs / l'utilisateur. Diag EXTERNE : `ss -xp | grep idea-mcp` (ponts) ; transcripts `~/.claude/projects/<run-dir-encodé>/*.jsonl` (horodatages UTC ; reply réel = `tool_use` idea_reply ; wedge = transcript demandeur figé sur `tool_use` idea_ask_agent sans `tool_result`).
+
+Scénario qui wedgeait (doit maintenant passer) :
+1. Faire déléguer **DevBackend → QA** : « réponds juste pong ».
+2. ATTENDU avec le fix : si QA répond en prose sans `idea_reply`, dans la grâce `PROMPT_READY_GRACE` le retour au prompt idle (`? for shortcuts`) déclenche `complete_without_reply` → **DevBackend reçoit `TargetReturnedNoReply` (retryable) et REPREND la main** (plus de wedge) ; `idea_workstate` QA repasse `working`→`idle`/`done` (plus de Busy fantôme). Lot 1 devrait en plus pousser QA à appeler `idea_reply` (chemin positif → DevBackend reçoit pong).
+3. Non-régression : chemin positif normal (QA appelle `idea_reply`) → demandeur reçoit le résultat, workstate→done ; livraison 1er tour à froid intacte.
+4. Calibrer `PROMPT_READY_GRACE` si la fenêtre est trop courte/longue en réel (défaut conservé).
+
+## Après validation verte
+Merge `develop` déjà fait. Reste éventuelle release (0.4.0 ?) = décision utilisateur. NB : **Git est de nouveau strictement local, PLUS d'accès push** (la note `git-agent-push-access-gitea-ssh` a été corrigée en ce sens). `develop` est ~69 commits devant `origin/develop` (sync remote hors périmètre Git).
+
+## Follow-ups différés (hors PR)
+Capture `prompt_ready_pattern` Codex ; généralisation merge profils de référence ; e2e délégation background (node_id None) / profils MCP défaut / observabilité UI des délégations ; durcissement doc `idea_reply` dans `CLAUDE.md` versionné (router à Git).

.ideai/memory/checkpoint-mcp-t1-t6-green-t7-fix-wrong-layer.md

@@ -0,0 +1,40 @@
+---
+name: checkpoint-mcp-t1-t6-green-t7-fix-wrong-layer
+description: memory note checkpoint-mcp-t1-t6-green-t7-fix-wrong-layer
+metadata:
+  type: project
+---
+---
+name: checkpoint-mcp-t1-t6-green-t7-fix-wrong-layer
+description: T1→T6 verts (non-régression). T7 ROUGE diagnostiqué (fix sur mauvaise couche) PUIS RE-FIX implémenté dans le working tree + vert en tests unitaires. Reste : rebuild AppImage en cours → relance IdeA → re-valider T1→T7 en live → commit Git.
+metadata:
+  type: project
+---
+# Checkpoint tests fonctionnels MCP — run a6ced819 (2026-06-24)
+
+Plan via skill **mcp-rendezvous-functional-test**, Main = demandeur. Setup chauds : Main/QA/DevFrontend ; froids : Architect/DevBackend/Git.
+
+## T1→T6 : VERTS sur AppImage 09:21 (aucune régression)
+T1 visibilité, T2 chaude `pong`, T3 réveil froid Git (1er tour intact), T4 background node_id None, T5 no-reply backstop (live-state purgée), T6 multi-étapes == oracle. Détails dans l'historique. NB outillage : `pgrep -af mcp-server | grep <uuid>` = FAUX positifs (le shell de mesure se matche) → filtrer `ps -eo cmd | grep 'app-tauri mcp-server'`.
+
+## T7 : défaut trouvé EN LIVE puis CORRIGÉ
+**Défaut (T7e live, 621 s ≈ 600 s)** : cible en long tour unique > 600 s (transcript en croissance prouvée) coupée par un timeout PLAT `process error: agent session reply timed out`, pas d'extension. Le watchdog du fix précédent vivait côté requester (`server.rs`) mais le seam qui coupe vraiment est `application/src/orchestrator/service.rs` (`ASK_AGENT_TIMEOUT`=600s plat appliqué au drain de tour délégué, ~L1564). **Fix posé sur la mauvaise couche.**
+
+**RE-FIX implémenté (subagent natif Architect→DevBackend→QA, worktree, ramené dans le main working tree ; HEAD toujours `1efe2f1`, NON committé)** :
+- Découverte clé : `ClaudeSdkSession::send().await` rend TOUS les `ReplyEvent` en bloc À LA FIN du tour (rien mid-turn) → la vivacité par-événement est inutilisable ; seul signe de vie réel = **sonde transcript** (octets `.jsonl`), comme `server.rs`.
+- Un seul `run_inactivity_watchdog` générique dans **`crates/application/src/orchestrator/rendezvous.rs`** (NOUVEAU, pur, testé), réutilisé par `service.rs` (le vrai seam) ET `server.rs` (copie privée supprimée → dé-duplication).
+- Nouveau port `AskLivenessProbe` injecté au composition root `app-tauri/state.rs` → `transcript_activity_token` (+ `with_ask_ceiling`, env `IDEA_ASK_RENDEZVOUS_CEILING_MS`, défaut 4 h). Sans injection ⇒ fallback fenêtre plate = zéro régression.
+- Issues typées : progrès<plafond → réarme ; progrès+plafond → `AppError::TargetCeilingActive` (code `RENDEZVOUS_CEILING_ACTIVE`, non-retry-aveugle) ; vrai silence → `AgentSessionError::Timeout` inchangé.
+- Défaut secondaire (busy fantôme) : `mark_target_done_best_effort` sur toutes les branches d'abandon (PTY + structuré).
+- Fichiers : application `{rendezvous.rs(new), service.rs, error.rs, lib.rs, orchestrator/mod.rs}`, infra `mcp/server.rs`, `app-tauri/state.rs` (+ les modifs infra inspector/lib pré-existantes du 1er fix).
+- **Preuve réelle (re-vérifiée par Main dans le MAIN TREE)** : `cargo test -p application --lib` 75/0 (dont progressing_target_extends_then_resolves, _hits_ceiling_distinctly, silent_target_expires_no_reply, no_probe_falls_back_to_flat_window, ceiling_active_code) ; `cargo test -p infrastructure --lib` 247/0 ; clippy 0 nouveau warning.
+
+## PROCHAINE ÉTAPE (reprise après relance IdeA)
+1. **Rebuild AppImage EN COURS** (recette : `npm --prefix frontend run build` puis depuis `crates/app-tauri/` `APPIMAGE_EXTRACT_AND_RUN=1 NO_STRIP=1 ../../frontend/node_modules/.bin/tauri build --bundles appimage` ; artefact `target/release/bundle/appimage/IdeA_0.3.0_amd64.AppImage` → remplace `/home/anthony/Documents/IdeA_0.3.0_amd64.AppImage`, backup l'ancienne). Log build : scratchpad/rebuild.log.
+2. **Utilisateur relance IdeA** (tue Main).
+3. **Reprendre le test depuis T1** (skill). Le but immédiat = **re-valider T7 EN LIVE** : déléguer une charge réelle > 600 s en un long tour (la machine est rapide : `cargo clean && cargo build --release --workspace` en boucle jusqu'à >13 min, transcript en croissance) ⇒ ATTENDU = PAS de timeout à 600 s, extension, reply final livré. Puis enchaîner T8 (parallèles), T9 (transitif A→B→C, Architect+DevBackend froids), T10 (interruption + reconcile reboot).
+4. **Si live vert : demander à Git de committer** le fix (cf. [[git-owns-commit-merge-decisions]]) ; rendez-vous MCP court marche (T2-T6), donc commit délégable à Git OU subagent natif.
+
+Lié à [[rendezvous-600s-cap-too-short-heavy-tasks]], [[mcp-functional-test-plan-2026-06-24]], [[mcp-bridge-and-delegation-runtime-notes]].
+</content>
+</invoke>

.ideai/memory/checkpoint-mcp-tests-t1-t5-and-t5-livestate-defect.md

@@ -0,0 +1,29 @@
+---
+name: checkpoint-mcp-tests-t1-t5-and-t5-livestate-defect
+description: memory note checkpoint-mcp-tests-t1-t5-and-t5-livestate-defect
+metadata:
+  type: project
+---
+---
+name: checkpoint-mcp-tests-t1-t5-and-t5-livestate-defect
+description: Run a6ced819 — relance complète T1→T6 du test fonctionnel MCP sur AppImage 08:41 (fix T5). T5 (live-state purgée sur no-reply) VALIDÉ EN LIVE. Blocage à T7 = défaut plafond 600s connu, non corrigé.
+metadata:
+  type: project
+---
+# Checkpoint tests fonctionnels MCP — run a6ced819 (2026-06-24, relance depuis T1)
+
+Binaire validé : **AppImage 2026-06-24 08:41:30** (fix live-state no-reply), process en cours = cette AppImage, git HEAD `1efe2f1`. Plan via skill **mcp-rendezvous-functional-test** (Main = demandeur). Voir [[mcp-functional-test-plan-2026-06-24]], [[rendezvous-600s-cap-too-short-heavy-tasks]], [[backstop-fires-on-intra-task-turn-rootcause]].
+
+## Résultats de la relance T1→T6 (tous ✅)
+- **T1** visibilité outils ✅ — 3 requesters chauds (Main, QA, DevFrontend) chacun pont ESTAB + 2 mcp-server ; froids (Architect, DevBackend, Git) 0 process.
+- **T2** cible chaude (QA) ✅ — `pong` inline borné, workstate `done`, pas de busy fantôme.
+- **T3** réveil à froid (Git) ✅ — nouveau pont (26012/26016), 1er tour `[IdeA·tâche…]` `parentUuid:null` intact, `delivered`, `pong-cold`.
+- **T4** background node_id None (Git hors layouts.json) ✅ — `bg-step-ok`, multi-`delivered`, pont stable sans dup.
+- **T5** no-reply backstop ✅ **VALIDÉ EN LIVE (le fix marche)** — Main libéré borné avec `TargetReturnedNoReply` (« returned to its prompt without calling idea_reply », retryable) ET **QA `status:"done"` purgée** (plus de busy fantôme `working`). Défaut historique #1 fermé.
+- **T6** multi-étapes (QA lit fichier + `find` puis reply) ✅ — pas de libération prématurée, reply réel `header=… ; rs_count=55` (concorde avec `find` indépendant). Piège turn-watcher non déclenché.
+
+## Blocage actuel : T7 (NON lancé — défaut connu non corrigé)
+T7 = tâche lourde > plafond 600s. C'est le finding [[rendezvous-600s-cap-too-short-heavy-tasks]] : dépassement du plafond `IDEA_ASK_RENDEZVOUS_TIMEOUT_MS` (défaut 600000) → faux `-32001` + canal de report mort (idea_reply final non livrable), alors que la cible travaille et finit sur la branche. Les pistes (extension sur signe de vie / message « cible active, plafond atteint » distinct du retryable / plafond configurable / pas de cascade) sont **à cadrer Architect, pas encore implémentées**. Lancer T7 en live = figer Main ~10 min pour re-confirmer un défaut déjà documenté.
+
+## Prochaine étape (décision utilisateur en attente)
+Trois options sur T7 : (a) le lancer quand même pour re-confirmer (wedge ~10 min) ; (b) ouvrir le cycle de fix du plafond maintenant (Architect→Git→DevBackend→QA, rebuild, reprise T1) ; (c) sauter T7 et continuer T8 (parallèles), T9 (transitif A→B→C), T10 (interruption + reconcile reboot) qui ne dépendent pas du plafond. Architect/DevBackend restent froids pour T9.

.ideai/memory/checkpoint-orchestrator-designation-appimage-build.md

@@ -0,0 +1,98 @@
+---
+name: checkpoint-orchestrator-designation-appimage-build
+description: memory note checkpoint-orchestrator-designation-appimage-build
+metadata:
+  type: project
+---
+# Checkpoint — AppImage rebuild après orchestrator-designation
+
+Date: 2026-06-20
+
+## État Git avant build
+
+Git avait clôturé `feature/orchestrator-designation`:
+- Commits atomiques créés:
+  - `287681c feat(orchestrator): ...`
+  - `e462136 feat(terminals): ...`
+  - `09f5362 docs: ...`
+  - `5ef001e chore(wip): ...`
+- Merge local dans `develop`: `55d887f merge(orchestrator): intègre le chantier orchestrator-designation dans develop`.
+- Branche `feature/orchestrator-designation` supprimée.
+- Worktree propre à ce moment-là.
+
+## Rebuild tenté
+
+Commande initiale:
+
+```bash
+npm --prefix frontend run build && \
+cd crates/app-tauri && \
+APPIMAGE_EXTRACT_AND_RUN=1 NO_STRIP=1 ../../frontend/node_modules/.bin/tauri build --bundles appimage
+```
+
+Résultat:
+- Frontend build OK.
+- Rust release build OK: `/home/anthony/Documents/Projects/IdeA/target/release/app-tauri`.
+- AppDir généré: `/home/anthony/Documents/Projects/IdeA/target/release/bundle/appimage/IdeA.AppDir`.
+- Bundling Tauri KO: `failed to run linuxdeploy`.
+
+## Contournement réussi
+
+`appimagetool` extrait existait dans:
+
+```text
+/tmp/appimage_extracted_02f96dbd6ecc47f616b5a57fb8b7aa60/usr/bin/appimagetool
+```
+
+L'appel direct à appimagetool échouait car réseau restreint:
+
+```text
+Failed to download runtime ... pass it to appimagetool with --runtime-file
+```
+
+Runtime extrait depuis l'ancienne AppImage locale:
+
+```bash
+/home/anthony/Documents/IdeA_0.2.0_amd64.AppImage --appimage-offset
+# 944632
+
+dd if=/home/anthony/Documents/IdeA_0.2.0_amd64.AppImage \
+  of=/tmp/idea-appimage-runtime-x86_64 \
+  bs=1 count=944632 status=none
+chmod +x /tmp/idea-appimage-runtime-x86_64
+```
+
+Commande finale réussie:
+
+```bash
+ARCH=x86_64 APPIMAGE_EXTRACT_AND_RUN=1 NO_STRIP=1 \
+/tmp/appimage_extracted_02f96dbd6ecc47f616b5a57fb8b7aa60/usr/bin/appimagetool \
+  --runtime-file /tmp/idea-appimage-runtime-x86_64 \
+  /home/anthony/Documents/Projects/IdeA/target/release/bundle/appimage/IdeA.AppDir \
+  /home/anthony/Documents/Projects/IdeA/target/release/bundle/appimage/IdeA_0.3.0_amd64.AppImage
+```
+
+Artefact produit:
+
+```text
+/home/anthony/Documents/Projects/IdeA/target/release/bundle/appimage/IdeA_0.3.0_amd64.AppImage
+Taille: 106M
+--appimage-offset: 944632
+```
+
+## État Git après build
+
+Le build/la session a laissé du runtime dirty:
+
+```text
+## develop...origin/develop [ahead 8]
+ M .ideai/conversations/6bc594e8-a37c-0dbd-1de6-6e3b73002cb4/handoff.md
+ M .ideai/conversations/6bc594e8-a37c-0dbd-1de6-6e3b73002cb4/log.jsonl
+ M .ideai/layouts.json
+```
+
+Ne pas nettoyer arbitrairement. Demander à Git de décider si ces fichiers runtime doivent être commités/ignorés au prochain passage.
+
+## Important live
+
+L'AppImage en cours d'exécution ne charge pas automatiquement ce nouvel artefact. Pour utiliser les correctifs d'orchestration/write-portal, lancer l'artefact 0.3.0 produit ci-dessus ou remplacer l'AppImage installée hors sandbox si nécessaire.

.ideai/memory/checkpoint-orchestrator-designation-backend-compile-fix.md

@@ -0,0 +1,54 @@
+---
+name: checkpoint-orchestrator-designation-backend-compile-fix
+description: memory note checkpoint-orchestrator-designation-backend-compile-fix
+metadata:
+  type: project
+---
+# Checkpoint — orchestrator-designation backend compile fix
+
+Date: 2026-06-20
+
+## Branche
+
+`feature/orchestrator-designation`.
+
+## Décision Git
+
+Finir le chantier courant sur cette branche. Pas de stash, pas de switch. Après tests verts ou résidu qualifié: retour Git pour commits atomiques puis merge local vers `develop`.
+
+## Incident live
+
+La délégation vers Architect a été affichée dans son chat mais non soumise. Architect a été stoppé. Symptôme cohérent avec l'AppImage live qui n'intègre pas encore les correctifs WIP write-portal/headless delivery.
+
+## Vérifications Main avant correction DevBackend
+
+Verts:
+- `cargo test -p infrastructure input --lib`: 35 passed.
+- `cargo test -p application --test orchestrator_service`: 45 passed.
+- `cd frontend && npx vitest run`: 41 files, 384 tests passed.
+- `cd frontend && npx tsc --noEmit`: OK.
+
+Rouge initial:
+- `cargo test --workspace` ne compilait pas `crates/application/src/orchestrator/context_guard.rs`:
+  - `may_write_directly` appelé avec 2 args au lieu de 3 (`OrchestratorDesignation` manquant).
+  - mauvais champ `orchestrator` mis sur `ManifestEntry` au lieu de `AgentManifest`.
+  - init `AgentManifest` sans `orchestrator`.
+
+## Correction DevBackend
+
+DevBackend a modifié `crates/application/src/orchestrator/context_guard.rs`:
+- `ProposeContext` charge `AgentManifest`, récupère `manifest.orchestrator_designation()`, puis appelle `may_write_directly(requester, &GuardedResource::ProjectContext, &designation)`.
+- Le `FileGuard` reste un verrou, pas le propriétaire de l'autorisation.
+- Tests locaux adaptés à `AgentManifest { version, entries, orchestrator }`.
+
+Validations DevBackend:
+- `cargo fmt --all && cargo test -p application --test orchestrator_service`: OK, 45 passed.
+- `cargo test -p application`: OK.
+- `cargo test --workspace`: compile maintenant plus loin mais échoue dans `app-tauri` sur tests loopback Unix socket sous sandbox (`PermissionDenied`/`Operation not permitted` lors du bind `/run/user/1000/idea-mcp/*.sock`).
+
+## Prochaine étape
+
+QA doit qualifier le résidu app-tauri:
+- confirmer que les suites métier/orchestration sont vertes,
+- confirmer si les échecs app-tauri sont environnement/sandbox et non régression,
+- proposer la commande de validation acceptable ou le besoin de correction test/env.

.ideai/memory/checkpoint-orchestrator-designation-qa-verdict.md

@@ -0,0 +1,42 @@
+---
+name: checkpoint-orchestrator-designation-qa-verdict
+description: memory note checkpoint-orchestrator-designation-qa-verdict
+metadata:
+  type: project
+---
+# Checkpoint — QA verdict orchestrator-designation
+
+Date: 2026-06-20
+
+## Branche
+
+`feature/orchestrator-designation`.
+
+## Verdict QA
+
+Chantier validable sous contrainte d'environnement. Pas de régression fonctionnelle liée à `context_guard.rs`.
+
+## Commandes vertes qui font foi
+
+- `cargo fmt --all -- --check`: OK.
+- `cargo test -p application --test orchestrator_service`: OK, 45 passed.
+- `cargo test -p application`: OK, suite application complète verte, incluant les tests context guard orchestrateur/proposition.
+- `cargo test -p infrastructure input --lib`: OK, 35 passed.
+- `cd frontend && npx vitest run`: OK, 41 files / 384 tests passed.
+- `cd frontend && npx tsc --noEmit`: OK.
+
+## Résidu app-tauri
+
+- `cargo test -p app-tauri --lib`: rouge, 39 passed / 8 failed.
+- `cargo test --workspace`: rouge sur le même bloc app-tauri.
+
+Échecs exacts: tests loopback Unix socket:
+- `mcp_bridge::tests::end_to_end_over_real_loopback`
+- `state::bind_endpoint_d1_tests::rebind_after_corpse_socket_succeeds`
+- `state::mcp_e2e_loopback_tests::*`
+
+Cause qualifiée par QA: contrainte environnement/sandbox. Une sonde Node minimale échoue aussi à `listen()` sur Unix socket avec `EPERM` sous `/run/user/1000` et sous `/tmp`. Donc les tests qui exigent un vrai socket Unix ne sont pas exécutables dans ce sandbox.
+
+## Prochaine étape
+
+Retour à Git pour commits atomiques sur `feature/orchestrator-designation`, puis décision de merge local vers `develop` selon sa stratégie. Aucun push.

.ideai/memory/checkpoint-orchestrator-designation-restart.md

@@ -0,0 +1,38 @@
+---
+name: checkpoint-orchestrator-designation-restart
+description: memory note checkpoint-orchestrator-designation-restart
+metadata:
+  type: project
+---
+# Checkpoint — reprise chantier orchestrator-designation
+
+Date: 2026-06-20
+
+## Situation
+
+L'utilisateur a demandé de terminer les chantiers ouverts. Main a repris le cycle proprement.
+
+## Décision Git obtenue
+
+Git a inspecté l'état local et décidé:
+
+- Branche courante: `feature/orchestrator-designation`.
+- Worktree dirty important mais analysé comme mono-thème: chantier orchestrateur/designation + diagnostic inter-agents.
+- Ne pas stash, ne pas switch, ne pas ouvrir une nouvelle branche maintenant.
+- Premier chantier à fermer: `orchestrator-designation` sur la branche actuelle.
+- Après stabilisation + tests verts: retour à Git pour commits atomiques puis merge local vers `develop`.
+- Ensuite seulement ouvrir des branches dédiées pour les autres chantiers.
+
+## Incident de délégation
+
+Main a tenté de demander à Architect de cadrer `orchestrator-designation` via `idea_ask_agent`.
+L'utilisateur a interrompu et signalé qu'Architect était bloqué avec le texte de la tâche affiché dans son chat mais non envoyé.
+
+Interprétation: symptôme cohérent avec les problèmes actuels de write portal / soumission physique PTY / délégation visible-background. Ne pas empiler de nouvelles délégations tant que cette zone n'est pas stabilisée.
+
+## Prochaine reprise recommandée
+
+1. Nettoyer/arrêter l'agent Architect bloqué si nécessaire.
+2. Reprendre le chantier courant localement en lecture seule pour identifier exactement les changements WIP liés à la soumission de délégations.
+3. Comme Main ne code pas, utiliser la délégation seulement vers un agent dont la soumission est confirmée fonctionnelle, ou lancer les agents en visible et vérifier qu'ils reçoivent réellement la tâche.
+4. Priorité technique immédiate: fermer `orchestrator-designation`, car la délégation inter-agents fiable conditionne tous les autres chantiers.

.ideai/memory/checkpoint-rendezvous-redesign-devbackend-todo.md

@@ -0,0 +1,38 @@
+---
+name: checkpoint-rendezvous-redesign-devbackend-todo
+description: memory note checkpoint-rendezvous-redesign-devbackend-todo
+metadata:
+  type: project
+---
+# Checkpoint — Backstop no-reply : 1ère validation live ÉCHOUÉE → cause racine corrigée → RE-VALIDATION LIVE EN ATTENTE (MAJ 2026-06-23 ~19:40)
+
+## Résultat du 1er test live (AppImage 0.3.0 du commit e87c05f) : ÉCHEC reproduisant le wedge
+Scénario joué : DevBackend→QA `ping (test backstop)`, QA répond `pong` EN PROSE sans `idea_reply`.
+- QA a bien émis un vrai `turn_duration durationMs=2218` (transcript, ts 17:23:40.161Z).
+- MAIS `[turn-watcher] turn_ended` JAMAIS émis (`grep -c turn_ended` sur tout le log = **0**) → DevBackend resté coincé → rendez-vous Main→DevBackend a timeout 600s (MCP error -32001).
+
+## CAUSE RACINE (prouvée) — encodage du slug projet Claude faux
+Traces `[turn-watcher] arm` : toutes `conversation=<none>` + `baseline … count=0`. Le dossier transcript calculé n'existait pas :
+- calculé (faux) : `…/-home-…-IdeA-.ideai-run-<uuid>` (point conservé) → `ls` = absent
+- réel (disque)  : `…/-home-…-IdeA--ideai-run-<uuid>` (DOUBLE tiret)
+`encode_cwd` (crates/infrastructure/src/inspector/claude_paths.rs) ne remplaçait que `/`/`\\` et gardait le `.`. Claude Code encode `replace(/[^a-zA-Z0-9]/g,'-')`. Dir introuvable → conversation non résolue → baseline 0 → `turn_duration` jamais vu → backstop mort.
+Log de référence : `/home/anthony/.local/share/app.idea.ide/logs/idea.log`.
+
+## FIX LIVRÉ par DevBackend (NON commité — Git tranche)
+- `encode_cwd` : `.map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })` (algo exact Claude Code). `/IdeA/.ideai/run` → `-IdeA--ideai-run`.
+- Test non-régression ajouté `encode_cwd_encodes_dot_in_run_dir_to_double_dash` (PASS). Test Windows maj `C:\\Users\\me`→`C--Users-me`.
+- DevBackend précise : `count_turn_ends` agrège déjà tous les `.jsonl` du dossier ⇒ pas besoin de choisir un .jsonl ; `conversation=<none>` à l'armement est normal et sans impact une fois le dir correct.
+
+## QA PRÉ-VALIDATION : VERTE
+`cargo test --workspace` = **1616 passed, 0 failed** ; `cargo clippy --workspace --all-targets` = 0 erreur. Nouveau test + 5 tests turn-watcher tous PASS.
+
+## EN COURS : rebuild AppImage (par Main, perms project-root OK)
+Recette : `npm --prefix frontend run build` puis depuis `crates/app-tauri/` `APPIMAGE_EXTRACT_AND_RUN=1 NO_STRIP=1 ../../frontend/node_modules/.bin/tauri build --bundles appimage`. Logs scratchpad fe-build.log / appimage-build.log. Sortie : `/home/anthony/Documents/Projects/IdeA/target/release/bundle/appimage/IdeA_0.3.0_amd64.AppImage`.
+
+## SEUL RESTE À FAIRE = RE-VALIDATION LIVE (garde-fou Git : pas de merge sans wedge prouvé levé EN LIVE)
+1. Utilisateur remplace l'AppImage installée par la nouvelle + relance IdeA (coupe la session).
+2. Session fraîche : rejouer DevBackend→QA pong-sans-`idea_reply`. ATTENDU cette fois : trace `arm … dir=…IdeA--ideai-run-… conversation=…` sur dossier EXISTANT + baseline NON nulle + `[turn-watcher] turn_duration detected … -> turn_ended` ⇒ libération du demandeur ~grâce (≈2s) avec résultat no-reply synthétique, et non-régression du chemin propre `idea_reply`.
+3. Si VERT → demander à Git d'amender/committer le fix sur `feature/rendezvous-no-reply-backstop` puis décider du merge develop. Si KO → relayer trace réelle à DevBackend.
+
+## Trou produit confirmé (hors scope, à planifier)
+Au reboot, `.ideai/live-state.json` non réconcilié : agents restent `working` fantôme (process morts). Fichier file-guardé, `idea_workstate_set` = self only, aucun reset cross-agent. Manque : réconciliation au boot OU outil orchestrateur de reset.

.ideai/memory/checkpoint-work-tab-blank-fix.md

@@ -0,0 +1,34 @@
+---
+name: checkpoint-work-tab-blank-fix
+description: memory note checkpoint-work-tab-blank-fix
+metadata:
+  type: project
+---
+# Checkpoint — Fix onglet Work vide
+
+Date: 2026-06-21
+
+## État final
+
+Correctif frontend de l'onglet Work vide terminé, validé QA (VERT) et mergé localement dans `develop`.
+
+- `develop` @ `a66881d` — merge local `--no-ff` du fix.
+- Commit de feature intégré : `3e1e553` (anciennement `9d2f186`, message amendé pour retirer le marqueur `(WIP, QA en attente)`).
+- Branche `fix/work-tab-blank-page` supprimée après merge.
+- Aucun push, aucune PR. `develop` en avance de 45 commits sur `origin/develop` (local-only).
+
+## Contenu du fix
+
+Normalisation défensive du work-state (`frontend/src/adapters/workStateNormalization.ts` nouveau) + adaptation panneau/mock/tests, pour qu'un work-state partiel/inattendu ne rende plus une page entièrement vide. 5 fichiers, +259/-47.
+
+## QA verte (sortie réelle)
+
+- `cd frontend && npx tsc --noEmit` → exit 0.
+- `cd frontend && npx vitest run` → 42 fichiers / 407 tests passed, exit 0.
+
+## Branches ouvertes restantes (non mergées dans develop)
+
+À cadrer/arbitrer avant intégration :
+- `feature/agent-skills` @ `ef101db` — domaine skills agent + use cases + FS store + injection LaunchAgent (L12).
+- `feature/agent-skill-awareness` @ `5be8987` — manifeste skills + outil MCP `idea_skill_read` + brief « capacités IdeA » dans contexte agent ; contient aussi un fix input cold-start (`e93a2c1`).
+- `fix/cold-start-delivery-race` @ `9590eac` — fix livraison délégation cold-start ; branche basée sur d'anciens commits release (0.1.0/0.2.0), potentiellement redondante avec `e93a2c1` de skill-awareness → vérifier avant merge.

.ideai/memory/checkpoint-workstate-controlled-actions-lot-d.md

@@ -0,0 +1,64 @@
+---
+name: checkpoint-workstate-controlled-actions-lot-d
+description: memory note checkpoint-workstate-controlled-actions-lot-d
+metadata:
+  type: project
+---
+# Checkpoint — Workstate controlled actions Lot D
+
+Date: 2026-06-20
+
+## État final
+
+Lot D `workstate controlled actions` terminé, validé QA et mergé localement dans `develop`.
+
+Branche finale:
+- `develop` @ `c1e99d1` — merge local `feature/workstate-controlled-actions`.
+- `feature/workstate-controlled-actions` conservée.
+- Aucun push, aucune branche supprimée.
+- Working tree propre après décision Git.
+
+## Commits créés
+
+- `3408c96` — `feat(workstate): actions contrôlées sur le work-state (Lot D backend)`
+  - Use cases agent-level `AttachLiveAgent` et `StopLiveAgent`.
+  - Commandes Tauri `attach_live_agent` et `stop_live_agent`.
+  - Attach rebind PTY/structured sans spawn; stop PTY/structured.
+  - DTO camelCase et wiring AppState/lib.
+
+- `1c6441b` — `feat(workstate): UI des actions contrôlées (Lot D frontend)`
+  - Port/adaptateur agent alignés sur le nouveau contrat attach + stop.
+  - Panneau Work: Open, Attach, Stop, View conversation, Copy summary.
+  - Work n'appelle pas `launchAgent`; Stop passe par `stopLiveAgent`; View/Copy n'utilisent que les previews Lot C.
+
+- `0976648` — `chore(wip): état runtime .ideai (flux conversation live)`
+  - Runtime isolé des commits feature.
+
+- `c1e99d1` — merge local dans `develop`.
+
+## QA verte
+
+Commandes QA/Git validées:
+- `cargo fmt --all -- --check` OK.
+- `cargo test -p application --test workstate_actions` OK, 7 passed.
+- `cargo test -p application --test workstate` OK, 21 passed.
+- `cargo test -p app-tauri --test dto_agents` OK, 25 passed.
+- `cargo test -p app-tauri --test list_live_agents_r0b` OK, 5 passed.
+- `cargo check -p app-tauri` OK.
+- `cd frontend && npx vitest run src/features/workstate/workstate.test.tsx src/features/projects/projects.test.tsx` OK, 25 tests.
+- `cd frontend && npx vitest run src/adapters/agent.test.ts` OK, 8 tests.
+- `cd frontend && npx vitest run src/features/layout/singletonAgent.test.tsx src/features/layout/agentAlreadyRunning.test.tsx` OK, 9 tests.
+- `cd frontend && npx tsc --noEmit` OK.
+
+Warnings restants uniquement côté Vite sur options `esbuild` dépréciées/ignorées au profit de `oxc`, non bloquants.
+
+## Décisions produit/techniques
+
+- Actions Lot D opèrent seulement sur l'état existant; pas de lancement d'agent neuf depuis Work.
+- Attach ne crée ni session ni cellule; cible déterministe = cellule visible vide côté UI.
+- Stop ne supprime ni agent, ni tickets, ni handoff/conversation summary.
+- View/Copy restent limités aux previews bornées Lot C; aucun log brut exposé.
+
+## Suite probable
+
+La quadrilogie Work A/B/C/D est intégrée. Prochains chantiers restants à cadrer: persistance conversationnelle/cross-profile plus profonde, mise à jour automatique mémoire/contexte pendant la vie des agents, ou synchronisation documentaire architecture selon priorité Architect/Main.

.ideai/memory/checkpoint-workstate-conversation-summaries-lot-c.md

@@ -0,0 +1,60 @@
+---
+name: checkpoint-workstate-conversation-summaries-lot-c
+description: memory note checkpoint-workstate-conversation-summaries-lot-c
+metadata:
+  type: project
+---
+# Checkpoint — Workstate conversation summaries Lot C
+
+Date: 2026-06-20
+
+## État final
+
+Lot C `workstate conversation summaries` terminé, validé QA et mergé localement dans `develop`.
+
+Branche finale:
+- `develop` @ `6e1ba7e` — merge local `feature/workstate-conversation-summaries`.
+- `feature/workstate-conversation-summaries` conservée.
+- Aucun push, aucune branche supprimée.
+- Working tree propre après décision Git.
+
+## Commits créés
+
+- `e9edadc` — `feat(workstate): résumés de conversation dans le read-model (Lot C backend)`
+  - `ProjectWorkState.conversations` top-level.
+  - Résumés best-effort depuis `HandoffStore`, fallback `ConversationLog::last(3)`.
+  - Déduplication des conversation ids issus des tickets, ordre first-seen.
+  - DTO camelCase et câblage Tauri.
+
+- `c50622e` — `feat(workstate): UI des résumés de conversation (Lot C frontend)`
+  - Types TS `ConversationWorkSummary` et previews.
+  - Mock normalise `conversations: []`.
+  - Panneau Work joint `tickets[].conversationId` vers `conversations[]` et affiche badge + preview compacte.
+
+- `78500d8` — `chore(wip): état runtime .ideai (flux conversation live)`
+  - Runtime isolé des commits feature.
+
+- `6e1ba7e` — merge local dans `develop`.
+
+## QA verte
+
+Commandes QA finales validées:
+- `cargo fmt --all -- --check` OK.
+- `cargo test -p application --test workstate` OK, 21 passed, aucun warning Rust.
+- `cargo test -p app-tauri --test dto_agents` OK, 21 passed.
+- `cargo check -p app-tauri` OK.
+- `cd frontend && npx vitest run src/features/workstate/workstate.test.tsx src/features/projects/projects.test.tsx` OK, 2 files / 19 tests.
+- `cd frontend && npx tsc --noEmit` OK.
+
+Warnings restants uniquement côté Vite sur options `esbuild` dépréciées/ignorées au profit de `oxc`, non bloquants.
+
+## Décisions produit/techniques
+
+- Source primaire: handoff conversationnel existant.
+- Fallback: derniers tours bornés du log, jamais le log brut complet.
+- Read-only et best-effort: les erreurs de preview ne bloquent pas `live/busy/tickets`.
+- Pas de nouvelle persistance, pas de mutation/réparation, pas de nouvelle action UX.
+
+## Suite probable
+
+Le prochain lot logique est Lot D: actions UX read/write contrôlées autour du panneau Work (ouvrir/rattacher cellule, voir conversation, arrêter agent, éventuellement copier résumé), à cadrer par Architect avant implémentation.

.ideai/memory/checkpoint-workstate-delegation-queue-lot-b.md

@@ -0,0 +1,62 @@
+---
+name: checkpoint-workstate-delegation-queue-lot-b
+description: memory note checkpoint-workstate-delegation-queue-lot-b
+metadata:
+  type: project
+---
+# Checkpoint — Workstate delegation/queue snapshot Lot B
+
+Date: 2026-06-20
+
+## État final
+
+Lot B `workstate delegation/queue snapshot` terminé, validé QA et mergé localement dans `develop`.
+
+Branche finale:
+- `develop` @ `64c2c14` — merge local `feature/workstate-delegation-queue`.
+- `feature/workstate-delegation-queue` conservée.
+- Aucun push, aucune branche supprimée.
+- Working tree propre après décision Git.
+
+## Commits créés
+
+- `cc7d99a` — `feat(workstate): snapshot des délégations en file par agent (Lot B backend)`
+  - `QueuedTicketSnapshot` + port read-only `AgentQueueSnapshot`.
+  - Impl `InMemoryMailbox` snapshot FIFO sans cloner les senders.
+  - `GetProjectWorkState.agents[].tickets` avec statut dérivé `inProgress/queued`, source `human/agent`, preview bornée.
+  - DTO Tauri camelCase et wiring `AppState` avec le même mailbox partagé en deux ports.
+
+- `c600604` — `feat(workstate): UI des délégations en file par agent (Lot B frontend)`
+  - Types TS `AgentTicketState`, `TicketWorkStatus`, `TicketWorkSource`.
+  - Mock gateway normalise `tickets: []`.
+  - Panneau Work affiche les tickets FIFO, source Human/Agent, preview, ticket court.
+  - Refresh ajouté sur `delegationReady`.
+
+- `5cb99fd` — `chore(wip): état runtime .ideai (flux conversation live, layouts)`
+  - Runtime isolé des commits feature.
+
+- `64c2c14` — merge local dans `develop`.
+
+## QA verte
+
+Commandes QA réelles validées:
+- `cargo fmt --all -- --check` OK.
+- `cargo test -p infrastructure mailbox --lib` OK, 13 passed.
+- `cargo test -p application --test workstate` OK, 12 passed.
+- `cargo test -p app-tauri --test dto_agents` OK, 20 passed.
+- `cargo check -p app-tauri` OK.
+- `cd frontend && npx vitest run src/features/workstate/workstate.test.tsx src/features/projects/projects.test.tsx` OK, 2 files / 17 tests.
+- `cd frontend && npx tsc --noEmit` OK.
+- QA ajoutée: `cargo test -p domain mailbox --lib` OK, 6 passed.
+
+Warnings observés uniquement côté Vite sur options `esbuild` dépréciées/ignorées au profit de `oxc`, non bloquants.
+
+## Décisions produit/techniques
+
+- Les tickets `human` et `agent` sont inclus dans le snapshot; l'UI distingue explicitement `Human` vs agent/requester au lieu de tout appeler délégation agent.
+- Le statut est dérivé à la lecture: `inProgress` si le ticket courant correspond au `busy_state`, sinon `queued`.
+- Pas de nouvelle persistance, pas de lecture `log.jsonl`/handoff, pas d'événement `agentQueueChanged`, pas d'action UX d'annulation/résolution.
+
+## Suite probable
+
+Le prochain lot logique du chantier UX conversations/délégations est Lot C: résumés de conversations depuis log/handoff en lecture best-effort, ou Lot D actions UX selon priorité produit. Suivre le cycle Main: Architect -> Git -> DevBackend/DevFrontend -> QA -> Git.

.ideai/memory/conversation-log-ls6-rotation-and-paginated-read.md

@@ -0,0 +1,29 @@
+---
+name: conversation-log-ls6-rotation-and-paginated-read
+description: Contrat figé de la rétention/rotation du transcript et de la lecture paginée riche (surface humaine).
+metadata:
+  type: reference
+---
+# LS6 — Rotation transcript + lecture paginée
+
+Hygiène de persistance du `log.jsonl` + surface de lecture humaine paginée (viewer LS7).
+
+## Invariant pivot INV-LS6
+La rotation n'élague/déplace JAMAIS un tour d'id ≥ `up_to` du handoff courant : le tour up_to + tous les postérieurs restent dans le segment ACTIF. Sans handoff (ou up_to nil) ⇒ aucune rotation. Garantit que `ConversationLog::read(since=up_to)` (fold incrémental) et la reprise restent corrects après rotation. Motif : `read(since)` cherche le curseur par position ; retirer up_to du fichier casserait le fold.
+
+## Rotation
+- Stratégie = **archive segmentée** (`log.jsonl` actif + `log.1.jsonl`… anciens), PAS troncature/suppression (transcript = surface humaine riche à préserver).
+- Déclencheur **hors chemin chaud** : use case `RotateConversationLog` à la reprise/ouverture, best-effort, idempotent. L'`append` ne déclenche JAMAIS la rotation (zéro latence ajoutée).
+- Seuils sur segment actif : `ROTATE_AFTER_TURNS=500` OU `ROTATE_AFTER_BYTES=1MiB`. Backstop disque `MAX_ARCHIVE_SEGMENTS=20` (drop du plus ancien seulement). Politique pure domaine `rotation_plan(...) -> Skip|Archive{keep_from=up_to}`.
+- Mécanique : verrou conversation bref ; réécriture actif **atomique en dernier** (tmp+rename) ; aucun tour perdu (∪ actif+archives) ; pagination dédoublonne par TurnId (crash-safe).
+
+## Lecture paginée (port ISP `ConversationArchive`, impl FsConversationLog)
+- `page(conversation, PageCursor{anchor,direction Forward|Backward}, limit)` → `TurnSlice{turns, has_more}`. limit clampé [1,200] défaut 50. Ordre chrono croissant. Archive-aware.
+- Use case `ReadConversationPage` → DTO humain `TurnPage{turns:[TurnView{id,at_ms,role,source,text COMPLET,text_len}], has_more, next_anchor}`. **Texte complet, non borné, non distillé** = surface HUMAINE.
+- `ConversationLog` (append/read/last) inchangé = vue segment actif (chemin chaud + dérivation).
+
+## Frontière
+Lecture riche consommée UNIQUEMENT par la commande Tauri du viewer humain, jamais par compose_convention_file/handoff/agent. Rotation ne touche que le transcript brut, jamais le handoff/injection.
+
+## Frontend
+LS6 = backend + commande Tauri `read_conversation_page`. Tout le React (viewer) = LS7.

.ideai/memory/conversation-rotation-safety-design.md

@@ -0,0 +1,49 @@
+---
+name: conversation-rotation-safety-design
+description: memory note conversation-rotation-safety-design
+metadata:
+  type: project
+---
+---
+name: conversation-rotation-safety-design
+description: Cadrage initial pour la compression/rotation automatique non interruptive des conversations d'agents.
+metadata:
+  type: project
+---
+
+# Conversation Rotation Safety Design
+
+Objectif : reduire le cout token des conversations longues sans degrader la stabilite des agents ni les contacts inter-agents.
+
+Socle existant a reutiliser :
+- log canonique `.ideai/conversations/<conversationId>/log.jsonl` ;
+- `handoff.md` incremental ;
+- injection du handoff au lancement/relaunch ;
+- `LeafCell.conversation_id` = id logique IdeA de paire, distinct du resumable provider ;
+- `providers.json` pour `(pair_conversation_id, provider_key) -> engine_session_id` ;
+- `InputMediator.busy_state(agent)` et FIFO par agent ;
+- `ask_agent` avec lock de tour par agent + wait-for graph anti-deadlock ;
+- attach/detach cellule deja modelise : la cellule est une vue, `TerminalSessions::rebind_agent_node` existe ;
+- frontend write-portal sait deja compter la saisie humaine et declarer `set_front_attached`.
+
+Regle produit centrale : rotation automatique opportuniste, jamais interruptive. IdeA ne compacte/rote une session qu'a un point sur.
+
+Conditions minimales avant rotation :
+- agent `Idle` (`InputMediator.busy_state == Idle`) ;
+- aucune delegation/ticket/reply en cours ;
+- aucun contact entrant en cours, sinon queue ou ancienne session jusqu'a bascule ;
+- checkpoint durable OK : prompt/response appendes au log + `handoff.md` a jour ;
+- cellule stable : pas d'attach/detach ou changement de layout en cours ;
+- utilisateur non en train d'ecrire : focus/buffer non vide/frappe recente/IME composition/prompt interactif detectable ;
+- nouvelle session demarree detached/background et prete avant bascule ;
+- bascule atomique routing logique + attachement cellule ; ancienne session retiree ensuite.
+
+Etat cible conceptuel :
+`RotationRequested -> WaitForAgentIdle -> WaitForNoDelegation -> WaitForNoIncomingRoute -> WaitForCellStable -> WaitForUserInputClear -> Checkpointing -> StartReplacementDetached -> AttachReplacementToCell -> SwitchRouting -> RetireOldSession`.
+
+Premier lot recommande : fondation non destructive.
+- Ajouter modeles/policy de `ConversationRotation` et raisons de blocage.
+- Ajouter query/use case d'evaluation qui retourne `Ready` ou `Blocked(reasons)` sans tuer ni relancer.
+- Exposer les signaux manquants de cellule/saisie depuis le frontend vers backend, d'abord comme etat consultable.
+- Publier des events de statut de rotation uniquement informatifs.
+- Ne pas implementer la bascule physique avant que les tests de surete soient verts.

.ideai/memory/conversation-viewer-ls7-frontend.md

@@ -0,0 +1,26 @@
+---
+name: conversation-viewer-ls7-frontend
+description: Contrat figé du viewer de transcript paginé (frontend pur, lecture seule, surface humaine).
+metadata:
+  type: reference
+---
+# LS7 — Viewer fil-par-paire (front pur)
+
+Dernier lot fonctionnel du programme persistance. UI humaine qui rejoue le transcript par paire, consomme la commande LS6 `read_conversation_page`. Lecture seule, zéro impact backend/agent.
+
+## Gateway / adapter / mock (patron WorkStateGateway)
+- Port `ConversationGateway.readPage(projectId, conversationId, {anchor?, direction?, limit?}) -> TurnPage`. Ajouter `conversation` à `Gateways`.
+- Types domaine : `TurnView{id, atMs, role: prompt|response|toolActivity, source: {kind:human}|{kind:agent,agentId}, text COMPLET, textLen}`, `TurnPage{turns, hasMore, nextAnchor}`.
+- Adapter `TauriConversationGateway` → invoke("read_conversation_page",{projectId,conversationId,cursor:{anchor,direction},limit}) + `conversationNormalization.ts` (mapper source Human/Agent calqué sur workStateNormalization). Mock avec pagination réelle + `_setTurns` pour tests offline.
+- Frontière : composant → useGateways().conversation → adapter → invoke. Jamais d'invoke direct.
+
+## Modèle d'affichage
+- Clé = conversationId. Entrée = drill-down depuis le Work panel (`ConversationWorkSummary.conversationId` déjà énuméré ; rendre les lignes cliquables via prop `onOpenConversation`). Pas de nouvel appel « liste conversations ».
+- Rejeu chrono croissant ; distinction sobre User↔Agent vs Agent↔Agent (parties déduites des sources, noms résolus depuis l'inventaire agents) ; toolActivity atténué/replié.
+- Pagination : ouverture backward/None = dernière page (bas du fil) ; scroll-up = backward ancré sur le tour le plus ANCIEN du buffer (préfixe, dédup par id, hasMore gate) ; refresh queue = forward ancré sur le plus récent (manuel ou sur domain events delegationReady/orchestratorRequestProcessed).
+
+## Intégration
+- État local `viewerConversationId` dans ProjectsView ; swap main-area (rend ConversationViewer à la place de LayoutGrid, PAS un nouveau kind backend) ; bouton retour ; reset au changement de projet. viewerConversationId=null ⇒ UI actuelle inchangée (non-régression terminal).
+
+## Frontière / backend
+Lecture seule (read_conversation_page LS6, hors chemin chaud), jamais injecté dans un contexte agent. **Aucune part backend** : juste vérifier la signature de la commande exposée et aligner l'adapter si écart.

.ideai/memory/feature-agent-skill-awareness-design.md

@@ -0,0 +1,50 @@
+---
+name: feature-agent-skill-awareness-design
+description: Design valide + decoupage de la feature « surfacer les skills assignes a un agent a la maniere MCP » (manifeste + idea_skill_read), a reprendre apres relance IdeA.
+metadata:
+  type: project
+---
+# Feature : skills connus de l'agent « a la MCP »
+
+Demarree le 2026-06-17. Branche Git **`feature/agent-skill-awareness`** (basee sur `develop` @ 8452333, qui contient deja le fix context-guard).
+
+## ETAT 2026-06-17 (apres-midi) : slice backend T1->T5 FAIT, VERT, COMMITTE.
+DevBackend a livre T1->T5, QA a couvert (23 tests, 1212 passed). Commits sur `feature/agent-skill-awareness` :
+- `ab34363` feat(skill-awareness): T1->T5 (manifeste # Skills disponibles + outil MCP idea_skill_read, description+effective_description, use case ReadSkill, cablage state.rs, dump legacy conserve en mode sans-MCP).
+- `1a10d67` fix(test): compteur d'outils MCP 11->12 (une 2e assertion codee en dur dans `crates/app-tauri/src/state.rs` ~l.2813 que QA avait ratee ; QA n'avait corrige que `infrastructure/tests/mcp_server.rs`).
+- `e93a2c1` = cherry-pick du fix cold-start (cf. Bug 8 dans [[mcp-bridge-and-delegation-runtime-notes]]) — present aussi sur la branche dediee.
+`cargo test --workspace` VERT sur l'arbre combine. **L'orchestrateur a committe lui-meme** (l'agent Git etait injoignable a cause du Bug 8) — A FAIRE RELIRE/REBASER PAR GIT une fois le canal restaure.
+
+**RESTE :** T6 (champ description dans creation/edition skill cote front) + T7 (e2e : rebuild AppImage avec le fix Bug 8, relance, agent neuf + skill assigne -> voit le manifeste + appelle idea_skill_read). Puis Git decide les merges (feature->develop ; fix cold-start->develop+main).
+
+## AJOUT 2026-06-17 (soir) : brief « capacites IdeA » INCONDITIONNEL — VERT, COMMITTE (566bff4)
+Besoin utilisateur elargi : un agent neuf ignorait TOUT le perimetre IdeA (pas que les skills). Cas vecu : « agremente le contexte du projet » -> l'agent reinvente son propre systeme de contexte car le bloc `# Orchestration IdeA` ne parlait QUE de delegation. Fix (GO Architect, meme fonction pure `compose_convention_file` lifecycle.rs, zero port/entite) : ajout d'un brief « capacites IdeA » TOUJOURS present (decrit la CAPACITE, jamais le contenu -> survit a memoire/contexte vides), dans les 2 surfaces, AVANT le persona :
+- mode MCP : nomme les outils contexte (`idea_context_read`/`idea_context_propose` avec semantique single-writer global HONNETE : proposition sans target = enregistree pour validation, PAS appliquee ; `idea_update_context` pour le .md d'un agent), memoire partagee (`idea_memory_read`/`idea_memory_write`), skills (`idea_skill_read`/`idea_create_skill`). Martele « le contexte projet d'IdeA EST le contexte, n'improvise jamais ton propre fichier ».
+- mode non-MCP : MEMES concepts via fichiers `.ideai/` UNIQUEMENT (CONTEXT.md, memory/+MEMORY.md, skills .md), AUCUN nom d'outil `idea_*` (cloisonnement strict des 2 surfaces — sinon casse `mcp_prose_*`/`non_mcp_prose_*`).
+QA : 5 tests dedies (brief inconditionnel des 3 capacites a zero contenu ; single-writer honnete ; non-MCP sans outil ; cloisonnement ; ordre avant persona). `cargo test -p application` = 0 failed (lib 52, agent_lifecycle 59). 1 assert existant adapte (`mcp_mode_without_skills_omits_section`). Commit atomique **566bff4** sur `feature/agent-skill-awareness` (Git a laisse les .ideai/ runtime hors commit). Merge feature->develop differe par Git jusqu'a T6+T7 (unite d'integration unique).
+
+## Historique
+Cycle initialement stoppe avant le code : la delegation MCP a wedge (Bug 7, puis Bug 8 residuel cf. [[mcp-bridge-and-delegation-runtime-notes]]).
+
+## Besoin
+Un agent neuf dans un projet neuf ignore les skills qui lui sont assignes (cas vecu : `build-appimage` assigne mais ignore, tout reinvente). Objectif : l'agent est **automatiquement au courant** de ses skills, comme il l'est des outils MCP, sans que l'utilisateur ait a le lui dire.
+
+## Decision produit (utilisateur, 2026-06-17) : approche « Manifeste + idea_skill_read »
+Diagnostic Architect : les skills sont DEJA injectes, mais (A) en VRAC (corps complet) en fin de `CLAUDE.md` -> lus comme de la doc, ignores ; (B) seulement au (re)lancement. On recadre « a la MCP » : affordances nommees+decrites en tete de contexte + chargement du corps a la demande.
+
+- Bloc **« # Skills disponibles »** injecte JUSTE APRES le bloc « # Orchestration IdeA » (haute altitude), listant `**<name>** — <description>` ; prose imperative + renvoi a `idea_skill_read(name=…)`. Omis si zero skill.
+- Nouvel outil MCP **`idea_skill_read(name)`** read-only, miroir exact de `idea_context_read`/`idea_memory_read` ; resout par nom (scope projet puis global), renvoie `content_md` inline ; erreur typee si introuvable/ambigu.
+- Champ **`description: Option<String>`** sur l'entite `Skill` + helper `effective_description()` (fallback : 1ere ligne non vide du `content_md`, nettoyee du `#`). `#[serde(default)]` sur l'index (retro-compat `index.json` legacy obligatoire).
+- Mode **sans MCP** (`profile.mcp` absent) : conserver l'ancien dump du corps complet (decision 4.2(b), zero regression).
+
+## Decoupage (commits atomiques par tache verte, decides par Git)
+- **T1 domaine** `crates/domain/src/skill.rs` : champ `description` + `effective_description()`.
+- **T2 store** `crates/infrastructure/src/store/skill.rs` (+ application/skill) : `description` dans IndexEntry (`serde(default)`), propage via `CreateSkill`.
+- **T3 convention-file** `crates/application/src/agent/lifecycle.rs` : section « # Skills disponibles » dans `compose_convention_file` (~l.2568, juste apres bloc Orchestration ~l.2586) ; alleger `resolve_skills` (~l.1202) pour n'utiliser que name+description (index, pas le corps) ; garder dump corps si non-MCP.
+- **T4 outil MCP** `crates/infrastructure/src/orchestrator/mcp/tools.rs` + commande `OrchestratorCommand::ReadSkill { name, requester }` + methode `read_skill` dans `OrchestratorService` + petit use case `ReadSkill` (compose le port `SkillStore` existant, AUCUN nouveau port).
+- **T5 cablage** `crates/app-tauri/src/state.rs` : injecter `ReadSkill` dans `OrchestratorService` (builder additif, comme le fix context-guard) + re-exports application (orchestrator/mod.rs + lib.rs).
+- **T6 front (differable)** `frontend` : champ description dans creation/edition de skill.
+- **T7 e2e** : rebuild AppImage + relance, agent neuf + skill assigne -> voit le manifeste + appelle `idea_skill_read`.
+
+## Pieges (Architect)
+Retro-compat `index.json` (serde default) ; resolution de nom ambigue (projet d'abord, erreur typee sinon) ; un skill assigne en cours de session reste invisible jusqu'au relaunch (limite inherente, comme MCP) ; pas de nouveau port, domaine = +1 champ, composition root seul point de cablage. GO Architect.

.ideai/memory/git-agent-push-access-gitea-ssh.md

@@ -0,0 +1,15 @@
+---
+name: git-agent-push-access-gitea-ssh
+description: memory note git-agent-push-access-gitea-ssh
+metadata:
+  type: project
+---
+**CORRECTION (2026-06-23) — annule et remplace la note précédente : l'agent Git N'A PLUS l'accès push. Il est de nouveau STRICTEMENT LOCAL, comme avant.**
+
+- Git gère **100 % du dépôt local** : commits, branches, merges/rebases locaux. Rien d'autre.
+- **Aucune action sortante** : pas de `git push`, pas de PR distante, pas de publication de tags, pas de synchronisation remote. Ce périmètre n'est PAS dans ses responsabilités.
+- Toute synchro avec un remote (`origin` Gitea ou autre) reste **hors périmètre Git** et sous décision/validation explicite de l'utilisateur, exécutée hors agent Git.
+
+Le contexte d'agent `git.md` reflète déjà ce retour au strictement-local (garde-fou « tu restes strictement local, pas de `git push` »).
+
+Voir [[git-owns-commit-merge-decisions]] (Git tranche toute la topologie LOCALE du dépôt).

.ideai/memory/git-owns-commit-merge-decisions.md

@@ -0,0 +1,12 @@
+---
+name: git-owns-commit-merge-decisions
+description: Ne jamais demander a l'utilisateur s'il faut committer/merger/brancher — c'est l'agent Git qui tranche toute la topologie du depot.
+metadata:
+  type: feedback
+---
+
+Je ne dois PLUS demander a l'utilisateur s'il faut committer, merger, OU gerer les branches (creer/checkout/switch/rebase/supprimer une branche, ni quoi, ni quand). TOUTE la gestion des branches et la topologie du depot est decidee par l'agent **Git** — c'est LUI qui tranche.
+
+**Why:** l'utilisateur a explicitement (CLAUDE.md §2.4 + confirme en session le 2026-06-17) defini Git comme garant du depot local : commits, merges, rebases ET toute la gestion de branches sont SA decision, pas celle de Main ni de l'utilisateur. Demander a l'utilisateur court-circuite ce role et le fait perdre du temps.
+
+**How to apply:** quand un lot est vert, je delegue a Git (`idea_ask_agent` target=Git) en lui livrant l'etat (fichiers, tests verts, etat de compilation) et c'est Git qui decide/execute commit, merge, ET la branche (creer une `feature/*`, switch, rebase, supprimer apres merge…). Avant de demarrer une nouvelle feature, je passe la main a Git pour la decision de branche. En cas de doute sur le versioning/branching, je demande a **Git**, jamais a l'utilisateur. Les actions SORTANTES (push/publication) restent la seule chose soumise a validation explicite de l'utilisateur. Voir [[session-limit-handling-design]].

.ideai/memory/handoff-ls5-summary-bound-and-llm-seam.md

@@ -0,0 +1,22 @@
+---
+name: handoff-ls5-summary-bound-and-llm-seam
+description: Contrat figé de la borne de handoff (perf) et du seam résumeur LLM non activé.
+metadata:
+  type: reference
+---
+# LS5 — Borne handoff + seam LLM
+
+Ferme le must-have perf du programme persistance : un `summary_md` non borné gonflait le contexte injecté à chaque lancement.
+
+## Borne summary_md (déterministe, en CARACTÈRES, pas tokens)
+- **Par tour** : `render_turn` tronque le texte aplati à `TURN_LINE_MAX_CHARS=240` (infra summarizer). Corrige le trou réel (un gros Response = ligne géante).
+- **Totale** : fn PURE domaine `bound_handoff_summary(Handoff, max)` + `HANDOFF_SUMMARY_MAX_CHARS=4096`. Stratégie de dépassement = **troncature distillée** (garde objectif + lignes les plus récentes, drop oldest, frontière de ligne). JAMAIS re-fold compactant, JAMAIS rejet (n'bloque jamais l'append du log). `up_to`/`objective` jamais modifiés. Idempotent.
+- **Appliquée à l'écriture** (`RecordTurn` après `fold`, avant `save` → borne universelle quel que soit le résumeur) **ET défensivement à l'injection** (`resolve_handoff` avant compose → protège les `handoff.md` legacy non bornés, sans migration).
+
+## Seam LLM : TRANCHÉ = « prêt mais NON activé »
+- Pas de vrai LLM en LS5 : `fold` tourne sur le chemin chaud (par tour, dans la délégation) → un appel réseau là = régression perf interdite. Défaut runtime reste `HeuristicHandoffSummarizer`.
+- Durcissement réel = la borne totale appliquée **dans RecordTurn (hors résumeur)** ⇒ un futur `LlmHandoffSummarizer` ne peut pas exploser le budget contexte.
+- Contrat futur adapter LLM (documenté) : déclenchement **froid/hors chemin** (reprise/rotation/débounce, jamais par tour) ; timeout + **fallback heuristique** (trait sans `Result`) ; sélection par flag, défaut heuristique. Trait `HandoffSummarizer::fold` inchangé.
+
+## Frontière
+Transcript = `log.jsonl` (jamais injecté). `summary_md` = dérivé distillé, désormais borné à l'écriture et à l'injection. Conforme « surface agent = borné/distillé ».

.ideai/memory/idea-program-surface-separation-and-livestate.md

@@ -0,0 +1,14 @@
+---
+name: idea-program-surface-separation-and-livestate
+description: Cadrage du programme post-skills : ce qui existe vs reste, et la règle de frontière surface-agent/humaine.
+metadata:
+  type: project
+---
+État au cadrage (develop @ 827d477) :
+- **#2a handoff incrémental cross-profile = FAIT + CÂBLÉ** (lots P1–P8) : `domain/conversation_log.rs` (`Handoff`, `HandoffStore`, `HandoffSummarizer::fold` incrémental, `ProviderSessionStore`), `application/conversation/record.rs` (`RecordTurn` = append+fold), wiring `state.rs` (`AppRecordTurnProvider`), injection au lancement via `HandoffProvider` (P7). Résumeur = `HeuristicHandoffSummarizer`, seam async pour `LlmHandoffSummarizer` (P10) déjà en place. Reste : seam LLM + borne `summary_md`.
+- **#2b log canonique = FAIT** : `ConversationLog` append-only `.ideai/conversations/<id>/log.jsonl`, **jamais injecté à un agent** (doc domaine explicite). Reste : rétention/rotation + lecture paginée UI.
+- **#1 live-state agent = À CONSTRUIRE (cœur)** : aujourd'hui seul `GetProjectWorkState` (read-model HUMAIN dérivé, non durable). Construire un 4ᵉ store `live-state.json` (**gitignored, runtime**) : `domain/live_state.rs` (`LiveState`/`LiveEntry`/`WorkStatus`, port `LiveStateStore`, **keyed last-writer-wins, JAMAIS append**, champs bornés, `prune` TTL+max_n), use cases `UpdateLiveState`/`GetLiveStateLean`, adapter `FsLiveStateStore`, auto-update depuis `orchestrator/service.rs` (ask→Working, reply→Done), injection bornée `# État du projet` au lancement + outils MCP `idea_workstate_read`/`idea_workstate_set`. Ne stocke QUE le non-re-dérivable (intent/progrès/dernière délégation) ; busy/queue restent calculés.
+
+**Règle de frontière gravée (testable)** : Surface AGENT = borné/distillé/pointeur uniquement (capacités, pointeurs mémoire, affordances skills, handoff `summary_md`, live-state lean). Surface HUMAINE = riche (ProjectWorkStatePanel, viewer fil-par-paire qui rejoue le log). **Transcript / append-only INTERDIT d'injection dans un contexte agent** ; seul un dérivé distillé franchit. 4 stores distincts : `memory/` (savoir stable, versionné) · `handoff.md` (reprise par fil) · `log.jsonl` (transcript humain) · `live-state.json` (coordination transitoire maigre).
+
+Découpage : LS0 doc baseline → LS1 domaine live-state → LS2 store+usecases → LS3 auto-update délégation → LS4 injection+MCP (clôt cold-start) ; LS5 seam LLM+borne handoff, LS6 rétention log+lecture UI (parallèles) ; LS7 UX fil-par-paire (front pur) ; LS8 doc clôture.

.ideai/memory/live-state-persistence-program-closed-ls8.md

@@ -0,0 +1,15 @@
+---
+name: live-state-persistence-program-closed-ls8
+description: Le programme live-state + persistance conversationnelle est livré et documenté ; pointe la doc de clôture et les points restés ouverts.
+metadata:
+  type: project
+---
+Programme **live-state / persistance conversationnelle CLOS** (LS1→LS7 livrés @ fd7adbb ; LS8 = doc de clôture).
+
+**Doc de référence** : `docs/LS8-live-state-persistence-closure.md` + `ARCHITECTURE.md` §21 (cartographie des 4 stores) ; §19 retitré « LIVRÉ » ; §14.1 et §18.5 corrigés (catalogue MCP **14**).
+
+**4 stores disjoints** : `.ideai/memory/` (savoir stable, versionné) · `handoff.md` (reprise distillée bornée ≤4096) · `log.jsonl` (transcript humain riche, JAMAIS injecté) · `live-state.json` (coordination maigre runtime, gitignoré). Surface AGENT bornée/distillée/pointeur ; surface HUMAINE riche ; seul le handoff distillé franchit vers un contexte agent.
+
+**Restant ouvert** : (1) activation seam LLM `LlmHandoffSummarizer` (non activé, défaut heuristique, contrat ADR LS5) ; (2) sweep périodique de rotation (idempotent, non câblé) ; (3) **discordance D19-4 ↔ .gitignore** : `.ideai/conversations/` devait être gitignoré mais est suivi — à trancher Git/Main ; (4) intégration MCP e2e UX ; (5) multi-fenêtres registre sessions ; (6) auto-update mémoire/contexte en cours de session.
+
+**Contrainte d'écriture** : un agent lancé en run-dir isolé (`.ideai/run/<id>/`) **ne peut pas écrire l'arbre du project root** (ARCHITECTURE.md, docs/) — les modifs de doc passent par Git (write+commit authority).

.ideai/memory/live-state-reboot-reconciliation-design.md

@@ -0,0 +1,21 @@
+---
+name: live-state-reboot-reconciliation-design
+description: memory note live-state-reboot-reconciliation-design
+metadata:
+  type: project
+---
+---
+title: Réconciliation du live-state au reboot (ReconcileLiveState)
+type: reference
+description: Décision d'architecture pour réconcilier les lignes live-state fantômes au redémarrage — seam, source de vérité, contrat de statut et préservation du self-only.
+---
+**Problème** : au reboot, `.ideai/live-state.json` n'est pas réconcilié → agents fantômes `working/waiting/blocked` alors que leurs sessions sont mortes. `prune` (TTL 6h) ne couvre pas le fantôme récent.
+
+**Décision (cadrage Architect, 2026-06-23)** :
+- **Seam** : étape best-effort `reconcile_live_state` dans la chaîne `open_project` (commands.rs), juste après `reconcile_layouts`. Pas d'app-boot global (live-state est par-projet). Pas d'outil MCP. Justification : un crash ne déclenche jamais `close_project`, donc **open est le seul filet fiable**.
+- **Source de vérité** : le registre de sessions vivantes `LiveSessions` / trait `LiveAgentRegistry` (`application/src/terminal/registry.rs`) — la *même* vérité que `GetProjectWorkState`. Prédicat orphelin = `status ∈ {working,waiting,blocked}` ET `!is_agent_live`. Race-safe : tourne avant toute relance ; LWW gagne via `updated_at_ms` frais.
+- **Contrat** : orphelin → `idle` (pas de nouveau statut, évite le ripple DTO/front). Garder `intent` (trace), vider `ticket` + `last_delegation` (rendez-vous mort, tracé ailleurs dans log/handoff), `progress` = marqueur stale, `updated_at_ms` frais.
+- **Pas de nouveau port.** Use case applicative `ReconcileLiveState` (compose `LiveStateStore` + `LiveAgentRegistry` + `Clock`) + transformation **pure** `LiveState::reconcile_orphans(is_live, now)` dans `domain/src/live_state.rs`. Provider par-root côté app-tauri (calqué sur `LiveStateProvider`/`live_state_for`).
+- **Self-only de `idea_workstate_set`** : invariant **de la surface MCP**, pas du store. `set_workstate` lie `agent_id`=identité handshake ; `UpdateLiveState`/`LiveStateStore` sont identity-agnostic. La réconciliation est un **acte système** dans le composition root qui appelle le port directement, **jamais** via `OrchestratorCommand::SetWorkState` → self-only préservé par construction. Même split que `snapshot_running_agents`/`reconcile_layouts`.
+
+Fichiers probables : `domain/src/live_state.rs`, `application/src/workstate/{mod.rs,reconcile.rs}`, `app-tauri/src/{lib.rs,state.rs,commands.rs}`. Voir [[live-state-persistence-program-closed-ls8]], [[handoff-ls5-summary-bound-and-llm-seam]].

.ideai/memory/mcp-e2e-findings-reply-wedge-phantom-busy.md

@@ -0,0 +1,47 @@
+---
+name: mcp-e2e-findings-reply-wedge-phantom-busy
+description: memory note mcp-e2e-findings-reply-wedge-phantom-busy
+metadata:
+  type: project
+---
+---
+name: mcp-e2e-findings-reply-wedge-phantom-busy
+description: Findings validation MCP e2e live (AppImage 0.3.0) — transport/rendez-vous SAINS ; un seul vrai défaut = wedge si l'agent délégué n'appelle pas idea_reply (pas de timeout serveur).
+metadata:
+  type: project
+---
+# Findings validation MCP e2e (live, AppImage 0.3.0) — 2026-06-22
+
+Contexte : validation réelle du parcours inter-agents (cf. [[resume-after-appimage-rebuild-mcp-e2e]]). Méthode = Main observe en externe (Bash sur `ss -xp` + transcripts `~/.claude/projects/<run-dir-encodé>/*.jsonl`), l'utilisateur déclenche dans l'UI ; on ne valide PAS via `idea_ask_agent`.
+
+## Scénario 1 — délégation vers agent FROID + cycle complet : VERDICT
+- ✅ **Réveil à froid** : déléguer vers un agent arrêté relance son pont (`mcp-server --requester <id>` réapparaît, socket ESTAB recompte).
+- ✅ **1er tour non perdu** : tâche livrée intacte = 1er `user` `[IdeA · tâche de <agent> · ticket <uuid>] …`.
+- ✅ **Chemin positif `idea_reply`** : quand l'agent cible appelle `idea_reply(ticket,result)`, le bridge répond `reply ... delivered`, le **demandeur reçoit le `tool_result` et reprend la main** (vérifié : DevBackend reçoit `pong` puis continue). 
+- ✅ **Purge live-state** : dès l'`idea_reply`, `idea_workstate` repasse le cible de `working` → `done`, intent vidé.
+
+➡️ **Transport + protocole de rendez-vous = SAINS.** Bugs historiques 3/4/5 OK sur ce chemin.
+
+## LE défaut restant (racine unique) — wedge sans `idea_reply`
+Si l'agent délégué **termine son tour sans appeler `idea_reply`** (ex. tâche triviale « réponds pong » → il répond `pong` en **prose** et s'arrête) :
+- le **demandeur wedge indéfiniment** dans `idea_ask_agent` (transcript demandeur figé sur le `tool_use` idea_ask_agent, aucun `tool_result`) ;
+- la **cible reste `working`** sur le ticket périmé dans la live-state ;
+- **aucun timeout ni récupération** côté serveur. Une interruption utilisateur du `ask` libère le demandeur mais **ne purge pas** le `working` de la cible (purge seulement à l'`idea_reply`).
+
+➡️ Le « Busy fantôme » n'est PAS un bug d'état indépendant : c'est la **conséquence** de l'absence d'`idea_reply`. Une seule cause à traiter.
+
+### Pistes correctif (à arbitrer Architect)
+1. **Durcir contextes agents** : « toute tâche déléguée se termine IMPÉRATIVEMENT par `idea_reply`, même triviale » (cheap, attaque la cause comportementale).
+2. **Garde-fou serveur (rendez-vous)** : timeout sur l'attente `idea_ask_agent` → renvoyer au demandeur un résultat d'échec/relance explicite + purger le `working` de la cible (idempotent). Touche le contrat rendez-vous + cycle de vie live-state = domaine Architect. Voir [[idea-program-surface-separation-and-livestate]], [[mcp-bridge-and-delegation-runtime-notes]].
+
+## Diagnostic / repro (rappels)
+- Ponts : `pgrep -af 'mcp-server --endpoint'` (1 requester = 2 process) ; `ss -xp | grep -c idea-mcp`.
+- Reply réel = `tool_use` `idea_reply` dans le transcript cible → tool_result `reply ... delivered` (⚠️ ne pas confondre avec les mentions `idea_reply` du CLAUDE.md injecté via attachments).
+- Wedge demandeur = transcript demandeur s'arrête sur `tool_use` `idea_ask_agent` sans `tool_result`.
+- ⚠️ Horodatages transcripts = **UTC** ; `ls %H:%M:%S` masque la date → comparer avec `date` + mtime réel (`ls -t`).
+
+## Restant à tester (scénarios e2e suivants)
+- Délégation vers agent BACKGROUND (node_id None) — même protocole, vérifier pas de 1er tour perdu.
+- `ask` sans réponse ne wedge pas durablement la CONNEXION du demandeur (vs juste l'appel) — Bug 5 côté transport.
+- Profils Claude/Codex utilisent MCP par défaut ; fallback fichier+prose cohérent.
+- Observabilité UI des délégations/replies (aujourd'hui opaque) — sujet UX.

.ideai/memory/mcp-functional-test-plan-2026-06-24.md

@@ -0,0 +1,45 @@
+---
+name: mcp-functional-test-plan-2026-06-24
+description: memory note mcp-functional-test-plan-2026-06-24
+metadata:
+  type: project
+---
+---
+name: mcp-functional-test-plan-2026-06-24
+description: Plan de test FONCTIONNEL du rendez-vous inter-agents MCP (trivial→tordu), à exécuter après rebuild develop HEAD ; méthode, ordre, setup IdeA et critères de réussite.
+metadata:
+  type: project
+---
+# Plan de test fonctionnel MCP inter-agents (2026-06-24, run a6ced819)
+
+Objectif : état des lieux par tests **fonctionnels** (pas unitaires) du rendez-vous `idea_ask_agent` ⇄ `idea_reply`, du trivial au plus tordu. On lance dans l'ordre, on **s'arrête au 1er blocage**, on corrige (cycle Architect→Git→Dev→QA), rebuild+relance, puis on **reprend de T1**. Contexte/historique : [[mcp-e2e-findings-reply-wedge-phantom-busy]], [[backstop-fires-on-intra-task-turn-rootcause]], [[rendezvous-no-reply-backstop-design]], [[rendezvous-600s-cap-too-short-heavy-tasks]], [[reconcile-live-state-implemented-feature-branch]].
+
+## Contexte binaire au moment du plan
+- AppImage qui tournait = build **23/06 19:42**, PÉRIMÉ (antérieur à `c6f0f86` encode_cwd, `744de20` backstop no-reply, `886bb0d`/`1efe2f1` reconcile). Décision utilisateur : **rebuild develop HEAD `1efe2f1` puis relance** avant de tester.
+- Règle structurelle : **binaire qui tourne = AppImage**. Tout fix backend ⇒ rebuild + relance d'IdeA (tue Main). Les tests s'enchaînent SANS relance *à l'intérieur d'une même version* ; chaque cycle de fix = 1 relance.
+
+## Méthode
+- **Main est le demandeur** (`idea_ask_agent`) = test fidèle de « si je donne un message à un agent, il me répond ».
+- Doublé d'**observation externe Bash** : ponts `ss -xp | grep idea-mcp` et `pgrep -af mcp-server` ; transcripts `~/.claude/projects/<run-dir-encodé>/*.jsonl` (horodatages **UTC** ; reply réel = `tool_use` idea_reply→tool_result `reply … delivered` ; wedge demandeur = transcript figé sur `tool_use` idea_ask_agent sans tool_result) ; live-state via `idea_workstate_read`.
+- Risque résiduel : un wedge non borné fige le tour de Main → l'utilisateur peut interrompre.
+
+## Setup IdeA à mettre en place avant T1 (consigne utilisateur)
+1. Relancer IdeA, ouvrir le projet IdeA, **Main visible** (le demandeur).
+2. Garder **2–3 cellules libres visibles** pour qu'on observe à l'œil les délégations (Main y placera des cibles visibles, ou lance-toi QA + DevFrontend dans des cellules visibles).
+3. **Laisser Architect, DevBackend, Git ARRÊTÉS (froids)** : T3 testera le réveil à froid ; T9 utilisera Architect+DevBackend froids.
+4. Cibles chaudes pour T1/T2 : Main les réchauffe lui-même (launch) — pas d'action requise.
+
+## Ordre des tests (trivial → tordu)
+- **T1 — Visibilité outils MCP.** Un agent lancé par IdeA voit ses outils sans action manuelle. Vérif : pont ESTAB (`ss`) + 2 process mcp-server par requester.
+- **T2 — Cible CHAUDE + idea_reply trivial.** Main→ask(agent chaud, « réponds pong via idea_reply »). Attendu : réponse inline `pong`, temps borné, workstate working→done purgé.
+- **T3 — Réveil à FROID + idea_reply.** Cible arrêtée. Attendu : pont relancé (nouveau mcp-server), **1er tour non perdu** (1er user `[IdeA · tâche…]` intact), reply remonte.
+- **T4 — Cible BACKGROUND (node_id None).** Délégation vers agent sans cellule visible. Attendu : même protocole, pas de 1er tour perdu (historiquement non testé).
+- **T5 — NO-REPLY (cible répond en prose, pas d'idea_reply).** Attendu backstop : demandeur libéré en temps borné avec `TargetReturnedNoReply` (retryable), **pas de Busy fantôme** (workstate purgé). DÉFAUT historique #1.
+- **T6 — Délégation MULTI-ÉTAPES puis idea_reply.** Cible lit plusieurs fichiers / lance une cmd PUIS idea_reply. Attendu : **pas de libération prématurée** pendant le travail, rapport final livré. PIÈGE turn-watcher (cause racine : backstop tirait au 1er tour interne ~3 s).
+- **T7 — Tâche LOURDE > plafond** (impl + `cargo test`/clippy). Attendu : extension sur signe de vie OU message clair « cible active, plafond atteint » (≠ faux `-32001`) ; idea_reply tardif non perdu. Plafond `IDEA_ASK_RENDEZVOUS_TIMEOUT_MS` (défaut 600000).
+- **T8 — Délégations PARALLÈLES** (2 cibles en 1 tour Main). Attendu : rendez-vous multiples simultanés OK, multiplexage pont, 2 réponses distinctes.
+- **T9 — TRANSITIVE A→B→C** (Main→Architect, Architect délègue à DevBackend puis reply à Main). Attendu : rendez-vous imbriqués, 2 attentes simultanées sans deadlock. Cas le plus tordu.
+- **T10 — INTERRUPTION/annulation + reconcile reboot.** (a) Main interrompt un ask en vol → `working` cible purgé, pas de cascade, idea_reply tardif non-livrable proprement. (b) Au reboot, orphelins status∈{working,waiting,blocked} & session morte → `idle` + marker `STALE_AT_RESTART_MARKER` (use case ReconcileLiveState, cf. [[reconcile-live-state-implemented-feature-branch]]).
+
+## Critère de fin
+Tous les T1→T10 verts avec preuve réelle (réponse inline + observation externe cohérente). Sinon : 1er rouge = blocage à corriger, puis reprise de T1.

.ideai/memory/mcp-functional-tests-t1-t9-green-live-2026-06-24.md

@@ -0,0 +1,33 @@
+---
+name: mcp-functional-tests-t1-t9-green-live-2026-06-24
+description: memory note mcp-functional-tests-t1-t9-green-live-2026-06-24
+metadata:
+  type: project
+---
+---
+title: MCP tests fonctionnels T1→T9 VERTS en live (2026-06-24, AppImage 12:53 HEAD 1efe2f1 + fix T7 non committé)
+type: project
+description: Passe complète T1→T9 verte en conditions réelles sur AppImage du 24/06 12:53 ; T5 (backstop no-reply) et T7 (watchdog inactivité >600s) validés live ; reste T10 (interruption + reconcile reboot) qui exige action utilisateur.
+---
+# Tests fonctionnels MCP rendez-vous — T1→T9 VERTS live (2026-06-24)
+
+Run a6ced819, plan [[mcp-functional-test-plan-2026-06-24]]. AppImage **rebuild 12:53 depuis l'arbre de travail** (HEAD `1efe2f1` + le fix T7 watchdog **non committé** mais présent dans les 11 fichiers modifiés du git status → embarqué dans le binaire). Méthode : Main demandeur + observation externe (ss/pgrep/transcripts UTC/workstate).
+
+## Résultats (preuve réelle)
+- **T1 visibilité MCP** ✅ : agents chauds = pont ESTAB + 2 mcp-server (app-tauri parent + AppImage) chacun.
+- **T2 cible chaude + reply trivial** ✅ : DevFrontend → `pong` inline, reply delivered 10:56:51 UTC, workstate done (pas de Busy fantôme).
+- **T3 réveil à FROID** ✅ : Git froid → `pong-cold` ; nouveau pont spawné, **1er tour `[IdeA·tâche]` intact** (régresseur encode_cwd résolu), reply delivered 10:57:34.
+- **T4 cible BACKGROUND (node_id None)** ✅ : Git background → `pong-bg`, reply delivered 10:58:14.
+- **T5 NO-REPLY backstop** ✅ (défaut historique #1 résolu) : cible répond en prose sans idea_reply → demandeur libéré en ~20 s avec erreur retryable « returned to its prompt without calling idea_reply », workstate cible done (PAS de Busy fantôme).
+- **T6 multi-étapes** ✅ (piège turn-watcher résolu) : DevFrontend lit fichiers + git log PUIS idea_reply ; pas de libération prématurée ; données réelles (142 fichiers, hashes corrects).
+- **T7 tâche LOURDE >600s** ✅ (défaut historique #2 résolu, validation live du fix watchdog) : QA charge réelle continue 11:00:46→11:12:44 UTC = **~11m58s**, cargo clean+build release+test (1632 passed/0)+clippy+9 relances ; rendez-vous **NON expiré à 600s**, idea_reply accepté au-delà du plafond (aucun « no pending request »), reply delivered 11:13:21.
+- **T8 PARALLÈLE** ✅ : 2 asks même tour (DevFrontend `alpha-8` + Git `beta-8`), réponses distinctes, multiplexage pont OK.
+- **T9 TRANSITIF A→B→C** ✅ : Main→Architect→DevBackend (les 2 froids) → `relay:gamma-9:done` ; rendez-vous imbriqués + double réveil à froid sans deadlock ; DevBackend reply delivered 11:14:32.
+
+## Reste : T10 (exige action utilisateur)
+- **T10a interruption** : Main interrompt un ask en vol → attendu : workstate cible purgé, pas de cascade, idea_reply tardif proprement non-livrable. NÉCESSITE que l'utilisateur appuie sur interrupt pendant un ask wedgé.
+- **T10b reconcile reboot** : orphelin status∈{working,waiting,blocked} + session morte → au reboot, use case ReconcileLiveState le passe à idle + `STALE_AT_RESTART_MARKER` (cf. [[reconcile-live-state-implemented-feature-branch]]). NÉCESSITE un reboot d'IdeA (ferme Main).
+
+## Suite recommandée
+1. Faire committer le fix T7 par Git (encore non committé, cf. [[git-owns-commit-merge-decisions]] + [[rendezvous-600s-cap-too-short-heavy-tasks]]).
+2. Exécuter T10 avec l'utilisateur (interrupt + reboot).

.ideai/memory/mcp-t10a-harness-interrupt-does-not-cancel-rendezvous.md

@@ -0,0 +1,29 @@
+---
+name: mcp-t10a-harness-interrupt-does-not-cancel-rendezvous
+description: memory note mcp-t10a-harness-interrupt-does-not-cancel-rendezvous
+metadata:
+  type: project
+---
+---
+title: T10a — l'interrupt harness du demandeur n'annule PAS le rendez-vous backend (reply tardif accepté dans le vide)
+type: reference
+description: Finding T10a (2026-06-24) — interrompre Main (demandeur) au niveau Claude Code ne propage aucune annulation à IdeA ; la cible finit, son idea_reply est « delivered » dans un demandeur abandonné, et la live-state du demandeur reste working.
+---
+# Finding T10a (2026-06-24, run a6ced819)
+
+## Setup
+Main → `idea_ask_agent(DevFrontend, "travaille ~90s puis idea_reply late-10a")`. Pendant l'attente, l'utilisateur **interrompt Main** (Échap harness Claude Code). Le tool use `idea_ask_agent` est rejeté côté harness.
+
+## Observé
+- DevFrontend a fini ses ~95 s de travail réel (11:20:39→11:22:14 UTC) puis `idea_reply("late-10a")` → **ACCEPTÉ « delivered »** à 11:22:18 (PAS « no pending request »).
+- DevFrontend workstate = **done** (pas d'orphelin côté cible). Pas de cascade.
+- **Main (demandeur) workstate resté `working`** : l'interrupt a coupé le tour de Main avant son nettoyage ; le chemin interrupt ne réconcilie pas la live-state du demandeur.
+
+## Interprétation
+L'interrupt Claude Code annule le **tool call local** mais le **process Main survit** → la socket MCP (mcp-server du demandeur) reste connectée → IdeA ne reçoit aucun signal d'annulation → le rendez-vous reste pending → le reply tardif de la cible est livré dans un demandeur qui a déjà abandonné (perdu pour Main mais rapporté « delivered »).
+
+## Conséquence
+- Le T10a du plan (« annulation en vol → reply tardif non-livrable proprement ») **n'est pas exerçable via interrupt harness** tant que le process demandeur survit. Une vraie annulation exigerait : tuer le process demandeur (drop socket) OU un cancel protocolaire JSON-RPC.
+- Comportement néanmoins bénin : pas de wedge, pas de cascade, cible réconciliée (done). Seuls écarts : (a) reply tardif « delivered » au lieu de rejeté ; (b) live-state du demandeur laissée working par le chemin interrupt (mais reconcile-au-reboot la rattraperait, cf. [[reconcile-live-state-implemented-feature-branch]]).
+
+Lié à [[mcp-functional-tests-t1-t9-green-live-2026-06-24]], [[mcp-functional-test-plan-2026-06-24]].

.ideai/memory/mcp-t10b-pending-reboot-verification.md

@@ -0,0 +1,24 @@
+---
+name: mcp-t10b-pending-reboot-verification
+description: memory note mcp-t10b-pending-reboot-verification
+metadata:
+  type: project
+---
+---
+title: T10b PASS — reconcile au reboot vérifié, inclut l'orchestrateur (2026-06-24)
+type: project
+description: T10b validé live après reboot. ReconcileLiveState ramène l'orphelin Main working→idle en conservant l'intent et purgeant ticket/lastDelegation. Couvre l'orchestrateur. Reste : faire committer par Git les fix non committés (T7 watchdog + reconcile).
+---
+# T10b — PASS (reboot reconcile vérifié)
+
+## Verdict
+Orphelin armé = Main `working` intent "T10b-ORPHAN-MAIN". Après reboot (run a6ced819), `idea_workstate_read` montre Main :
+- `status: idle` ✅ (était working)
+- `intent` conservé ✅
+- `ticket` purgé ✅ / `lastDelegation` purgé ✅
+
+Signature `STALE_AT_RESTART_MARKER` complète. **ReconcileLiveState valide ET inclut l'orchestrateur** (Main n'a PAS été exclu malgré la crainte du design open_project). Champ `progress` non exposé par workstate_read mais transition working→idle+intent retenu = concluante.
+
+## Suite du plan
+T1→T10 du plan [[mcp-functional-test-plan-2026-06-24]] terminés (T1→T9 verts cf. [[mcp-functional-tests-t1-t9-green-live-2026-06-24]], T10a finding [[mcp-t10a-harness-interrupt-does-not-cancel-rendezvous]], T10b PASS ici).
+**RESTE : faire committer par Git les fix non committés (T7 backstop/watchdog + reconcile live-state).** cf. [[git-owns-commit-merge-decisions]].

.ideai/memory/mcp-t7-backstop-600s-reply-rejected-livestate-stale.md

@@ -0,0 +1,37 @@
+---
+name: mcp-t7-backstop-600s-reply-rejected-livestate-stale
+description: memory note mcp-t7-backstop-600s-reply-rejected-livestate-stale
+metadata:
+  type: project
+---
+---
+title: MCP T7b/T7e — backstop 600s rejette le reply tardif et laisse le live-state worker non réconcilié
+type: reference
+description: Finding fonctionnel des tests MCP T7b/T7e (2026-06-24) — un idea_reply après dépassement de la fenêtre 600s est refusé « no pending request », et le ticket du worker reste working dans le live-state.
+---
+
+# Finding — tests MCP T7 (2026-06-24, QA)
+
+## Contexte
+Série de tests du rendez-vous `idea_ask_agent ⇄ idea_reply` et du backstop no-reply (cap ~600s), demandés par Main :
+- **T7d** (debug build x3, avant-plan) : cumul ~3m49s < 600s → reply OK.
+- **T7b** (9 étapes `sleep 82`, entrelacées) : le harness BLOQUE tout `sleep` avant-plan → exécutées en run_in_background ; reply OK (tardif mais < fenêtre côté ticket T7b).
+- **T7e** (release build répété, avant-plan, sans sleep ni bg) : 7 cycles, cumul réel **08:01:14 → 08:14:21 = 13 min 07 s**, franchit largement 600s.
+
+## Défaut observé
+À la fin de T7e (et de T7b, terminé au même tour, après >600s d'occupation continue), les DEUX `idea_reply` (tickets `4613262f…` T7b et `d2398b22…` T7e) sont refusés :
+
+```
+invalid input: no pending request to reply to for agent aefdbd61-…
+```
+
+→ Le backstop a libéré le **demandeur** (Main) côté rendez-vous après dépassement du cap, ce qui est le comportement voulu. MAIS :
+1. Le **résultat réel** (builds OK, horodatages non falsifiés) ne peut **plus être délivré** : il est perdu pour le demandeur.
+2. `idea_workstate_read` montre encore le worker QA `status=working ticket=d2398b22…` **après** le rejet du reply → le live-state du **worker** n'est PAS réconcilié quand le backstop ferme le rendez-vous côté demandeur. Incohérence demandeur (libéré) vs worker (toujours working).
+
+## Conséquence / piste
+- Le cap 600s du rendez-vous reste trop court pour des tâches lourdes légitimes (cf. [[rendezvous-600s-cap-too-short-heavy-tasks]]) : ici un travail réel et honnête >13 min est « jeté ».
+- À corriger : quand le backstop ferme un rendez-vous, soit (a) accepter encore un reply tardif (le router vers le demandeur même après timeout / le persister), soit (b) réconcilier le live-state du worker (passer son ticket à done/abandon) pour ne pas laisser un `working` fantôme. Voir [[backstop-fires-on-intra-task-turn-rootcause]] et [[rendezvous-no-reply-backstop-design]].
+
+## Reproductible
+Charge avant-plan réelle (`cargo build --release --workspace` en boucle clean) dépassant 600s, puis tenter `idea_reply` sur le ticket d'origine → rejet systématique.

.ideai/memory/permissions-sandbox-system-state.md

@@ -0,0 +1,26 @@
+---
+name: permissions-sandbox-system-state
+description: Etat du systeme de permissions/sandbox IdeA (domaine pur -> projection advisory -> enforcement OS Landlock sur PTY ET structure) et l'unique risque residuel.
+metadata:
+  type: project
+---
+# Systeme de permissions / sandbox IdeA
+
+Chantier "permissions des agents" complet bout-en-bout au 2026-06-16, sur la branche `wip/p8c-checkpoint-before-codex`. Lots committes : LP4-0 (`b05d04a`), LP4-1/LP4-2 (`17ca65e`), LP4-3 (`7e01ac6`), LP4-4 (`6236cd7`).
+
+## Acquis (tout vert, ~80 suites)
+
+- **Domaine pur** (`crates/domain/src/permission.rs`, `sandbox.rs`) : modele declaratif (`Capability`, `Effect`, `Posture` Allow<Ask<Deny, deny-wins), `resolve()` (invariant produit : rien pose => `None` => CLI garde son prompting natif), `compile_sandbox_plan(eff, ctx) -> Option<SandboxPlan>`, port `SandboxEnforcer`, `render_permission_summary` (honnetete : fichiers = OS-enforced, commandes = advisory).
+- **Store** : `.ideai/permissions.json` (separe d'`agents.json` : securite projet, pas identite).
+- **Projection advisory LP3** : projecteurs Claude (`settings.json`) + Codex (sandbox/`config.toml`).
+- **Enforcement OS LP4** : `LandlockSandbox` (Linux) / `NoopSandbox` / `default_enforcer()`. Actif sur **les deux chemins** : PTY brut (`pty/mod.rs` `spawn_command_sandboxed`) ET structure Claude/Codex JSON (`session/process.rs` `run_turn_sandboxed`).
+
+## Technique d'enforcement (load-bearing, ne pas casser)
+
+`enforce(plan)` tourne sur un **thread jetable AVANT le spawn**, puis le child est spawne depuis ce thread => il herite le domaine Landlock via les credentials de la tache (garanti par le noyau a travers fork/clone/execve, y compris posix_spawn). **Pas de `pre_exec`** : `infrastructure` est `#![forbid(unsafe_code)]` (intact), et le pre_exec n'aurait ete qu'une assurance de determinisme, sans valeur de securite ; allouer dans `landlock` post-fork (pre_exec) serait au contraire dangereux (deadlock malloc en process multithreade). Fail-closed : `Err` d'enforce => aucun child. Le garde-fou anti-regression est le test e2e **"ecriture hors-grant bloquee"** (present pour PTY et structure) : tant qu'il est vert, l'heritage tient.
+
+## Risque residuel a traiter (signale par l'Architecte, NON couvert)
+
+Les CLI structurees (claude/codex = binaires Node) ont des besoins FS ambiants lourds : `~/.claude`/`~/.codex` (credentials + cache de session pour le **resume**), `node_modules`, libs systeme, caches temp. `compile_sandbox_plan` ne fence que les classes explicitement posees et garde les lectures ouvertes — mais une policy posant un `Deny`/posture restrictive touchant `$HOME` **peut casser le resume**. Le mecanisme est valide au fake CLI (zero token), mais **avant d'activer un plan restrictif en prod sur le chemin structure**, valider e2e manuellement qu'un vrai tour claude/codex sous plan representatif garde run_dir + home de la CLI atteignables. C'est un sujet de **composition du plan** (run_dir reachability ; `SandboxContext.run_dir` existe mais n'est pas encore consomme par la traduction pure), pas du mecanisme — lot suivant si besoin.
+
+Voir [[remaining-work-idea-agent-control-ide]] pour le reste des chantiers produit.

.ideai/memory/reconcile-live-state-implemented-feature-branch.md

@@ -0,0 +1,25 @@
+---
+name: reconcile-live-state-implemented-feature-branch
+description: memory note reconcile-live-state-implemented-feature-branch
+metadata:
+  type: project
+---
+---
+title: Réconciliation du live-state au reboot — implémentée (feature/reconcile-live-state)
+type: project
+description: Le chantier ReconcileLiveState (3 lots) est implémenté et vert (1623 tests), non committé ; détail des fichiers et de l'arbitrage project_id/provider.
+---
+
+Implémenté le 2026-06-23 sur `feature/reconcile-live-state` (ticket Main a7fcb5e4, dont le rendez-vous `idea_reply` a expiré pendant le build — résultat consigné ici). **Non committé** (Git tranche). Cadrage : [[live-state-reboot-reconciliation-design]].
+
+**Résultats réels** : `cargo test --workspace` = **1623 passed, 0 failed**. `cargo clippy --workspace --all-targets` = 0 erreur, aucun warning sur le code ajouté (warnings restants tous pré-existants).
+
+**Lot 1 (domaine, `crates/domain/src/live_state.rs`)** : `LiveState::reconcile_orphans(is_live, now_ms) -> Vec<LiveEntry>` pure (ne mute pas self). Orphelin = status ∈ {Working,Waiting,Blocked} ET !is_live → réécrit status=Idle, intent gardé, ticket=None, last_delegation=None, progress=Some(`STALE_AT_RESTART_MARKER`), updated_at_ms=now. Const pub `STALE_AT_RESTART_MARKER = "(stale — session not running at restart)"`. +4 tests.
+
+**Lot 2 (application, nouveau `crates/application/src/workstate/reconcile.rs`)** : use case `ReconcileLiveState` sur `LiveStateStore`+`LiveAgentRegistry`(ISP)+`Clock` ; `execute(ReconcileLiveStateInput{project_id})` charge → reconcile_orphans → upsert par ligne. +3 tests. Exporté via workstate/mod.rs + application/lib.rs.
+
+**Lot 3 (app-tauri, `state.rs`+`commands.rs`)** : provider par-root `AppReconcileLiveState` (résout root via `ProjectStore::load_project`, `FsLiveStateStore::new(&root)`, registre = `LiveSessions` existant). Champ `reconcile_live_state` sur AppState. Hook best-effort dans `open_project` après `reconcile_layouts`. **Acte système** : écrit le port `LiveStateStore` directement, jamais via `OrchestratorCommand::SetWorkState` → self-only de `idea_workstate_set` préservé par construction.
+
+**Arbitrage à valider QA/Architect** : la résolution project_id→root se fait au composition root (le store est root-bound), donc `ReconcileLiveState::execute` reçoit bien `ReconcileLiveStateInput{project_id}` (conforme Lot 2 + hook Lot 3 à la lettre) mais ne relit pas project_id dans le flux pur (`_input`). Variante sans ce param redondant = ajustement trivial si souhaité.
+
+**Fichiers (6)** : domain/src/live_state.rs ; application/src/workstate/reconcile.rs (nouveau) ; application/src/workstate/mod.rs ; application/src/lib.rs ; app-tauri/src/state.rs ; app-tauri/src/commands.rs.

.ideai/memory/rendezvous-600s-cap-too-short-heavy-tasks.md

@@ -0,0 +1,37 @@
+---
+name: rendezvous-600s-cap-too-short-heavy-tasks
+description: memory note rendezvous-600s-cap-too-short-heavy-tasks
+metadata:
+  type: project
+---
+---
+name: rendezvous-600s-cap-too-short-heavy-tasks
+description: FIX LIVRÉ (2026-06-24) du plafond rendez-vous 600s trop court (T7) — watchdog d'inactivité + extension sur signe de vie + plafond absolu, message distinct cible-active vs no-reply. Built, tests verts, AppImage 09:21 ; validation live T7 en attente.
+metadata:
+  type: project
+---
+# T7 — plafond rendez-vous trop court : FIX LIVRÉ (2026-06-24)
+
+## Défaut (rappel, observé 2026-06-23)
+Délégation dev lourde (impl + `cargo test --workspace` + clippy) → la cible bosse en **un seul long tour > 600 s sans émettre de `turn_duration`**. L'enveloppe serveur `timeout(600s, dispatch)` plate (`crates/infrastructure/src/orchestrator/mcp/server.rs`) expirait sec : (a) faux `-32001`/no-reply **retryable** alors que la cible n'est pas muette mais active ; (b) drop du `dispatch` → canal de report mort → `idea_reply` final non livrable (« no pending request »).
+
+## Fix (branche de travail courante, pas encore committé)
+Implémenté par subagent Claude (Architect+DevBackend, hors `idea_ask_agent` car le rendez-vous était le sujet), vérifié par Main (QA réelle), AppImage rebuildée.
+- **Algorithme `run_inactivity_watchdog`** dans `server.rs` : `ASK_RENDEZVOUS_TIMEOUT` (600 s, env `IDEA_ASK_RENDEZVOUS_TIMEOUT_MS`) devient une **fenêtre d'inactivité (budget de silence)**, pas un plafond absolu. Boucle `timeout(fenêtre, dispatch)` ; à chaque expiration, sonde l'activité de la cible :
+  - progrès & sous plafond → réarme (extension) ;
+  - progrès & plafond atteint → **`rendezvous_ceiling_active_error`** (nouveau code JSON-RPC `error_codes::RENDEZVOUS_CEILING_ACTIVE = -32_002`, `data.code="RENDEZVOUS_CEILING_ACTIVE"`, **`retryable:false`**, message « still actively working… do not retry blindly, check the target's in-progress work/branch ») ;
+  - pas de progrès (vrai silence, ou **pas de probe = fallback plat**) → `rendezvous_no_reply_error` inchangé (`retryable:true`).
+- **Signe de vie = octets cumulés des `.jsonl`** du run-dir cible (couvre le long tour unique sans `turn_duration`). Nouvelle `inspector::claude_paths::transcript_activity_token(fs, home, cwd) -> Option<u64>`.
+- **Plafond absolu** `ASK_RENDEZVOUS_CEILING` (défaut **4 h**, env `IDEA_ASK_RENDEZVOUS_CEILING_MS`).
+- **Wiring** : sonde optionnelle `AskActivityProbe` injectée dans `McpServer` (modèle `events`/`ready_sink`, additif → zéro régression), branchée par la composition root `crates/app-tauri/src/state.rs` (qui résout nom→AgentId→run-dir via nouveau `service.resolve_agent_id_by_name`). Infra reste libre d'`AgentId`.
+- Fichiers : `server.rs`, `jsonrpc.rs`, `mcp/mod.rs`, `lib.rs`, `inspector/claude_paths.rs`+`mod.rs`, `application/.../service.rs`, `app-tauri/state.rs`.
+
+## Validation (preuve réelle, Main)
+`cargo test -p infrastructure --lib` = **251 passed/0** (dont 6 nouveaux tests : silence→no-reply, fallback sans probe→no-reply, active→extension puis resolved, active→ceiling, codes/retryable distincts). `mcp_server` 22/0, `inspector_claude` 4/0, `cargo test -p application` tout vert. `clippy -p infrastructure -p application --all-targets` = **0 warning nouveau** (résiduels pré-existants : input/mod.rs, lifecycle.rs, fileguard.rs, server.rs:132 ready_sink). **AppImage rebuildée 2026-06-24 09:21**, installée sur `/home/anthony/Documents/IdeA_0.3.0_amd64.AppImage`, backup `…​.old-pre-t7-fix` (08:41).
+
+## Reste à faire
+1. **Validation live T7** après relance IdeA : déléguer une tâche lourde >600 s ; attendu = pas d'expiration tant que la cible écrit son transcript, et soit résolution normale, soit (si >4 h) message ceiling-active non-retryable distinct ; idea_reply tardif non perdu tant qu'on n'a pas atteint le plafond.
+2. **Commit par Git** (non fait — laissé à Git, cf. [[git-owns-commit-merge-decisions]]) : décider de le faire avant ou après la validation live T7.
+3. Reprise complète des tests **depuis T1** (skill mcp-rendezvous-functional-test). État pré-relance : T1→T6 verts cette passe, dont fix T5 validé live (cf. [[checkpoint-mcp-tests-t1-t5-and-t5-livestate-defect]]).
+
+Lié à [[rendezvous-no-reply-backstop-design]], [[backstop-fires-on-intra-task-turn-rootcause]], [[mcp-functional-test-plan-2026-06-24]].

.ideai/memory/rendezvous-no-reply-backstop-design.md

@@ -0,0 +1,14 @@
+---
+name: rendezvous-no-reply-backstop-design
+description: Décision d'architecture sur la fin-de-tour et le backstop no-reply du rendez-vous idea_ask_agent ⇄ idea_reply, après échec live du fix Finding A (77e62e5).
+metadata:
+  type: reference
+---
+Le watcher prompt-ready PTY (`infrastructure/src/input/mod.rs` `arm_prompt_watcher`) ne peut PAS servir de signal de fin-de-tour : il est one-shot ré-armé seulement au `bind_handle`, et matche un bandeau TUI **permanent** (`? for shortcuts`) — donc inopérant par tour. Preuve live : aucun `prompt_ready` de toute une session alors que l'agent a travaillé ⇒ c'est le handshake MCP `initialize` (→ `release_agent_cold_start`) qui libère le cold-start, pas le PTY.
+
+**Contrat figé** : `idea_ask_agent` est garanti libéré en temps borné par l'un de :
+1. `idea_reply` (chemin propre, renforcé par le préambule comportemental injecté à chaque délégation) ;
+2. backstop no-reply sur **stagnation** — transition `Alive→Stalled` (lot-2 `arm_liveness`/`sweep_stalled`) du `Busy{ticket}` ⇒ résolution synthétique « cible silencieuse sans idea_reply » + libération du demandeur ;
+3. timeout absolu **fini** (dernier recours) — `ASK_RENDEZVOUS_TIMEOUT` ne doit JAMAIS être 24h ; défaut reco 600 s, env-overridable, garde `Some(0)=no-override`. La borne applicative per-tour (`resolve_turn_timeout`) doit aussi être finie.
+
+Le scraping d'octets ANSI bruts est interdit comme autorité de fin-de-tour (fragile, profil-spécifique). Cold-start = signal MCP `initialize`. Aucun port domaine ni contrat de cartographie n'est touché : tout est infrastructure/application (réutilise lot-2 + sink MCP). Diagnosticabilité : les logs d'armement/bind doivent être en `diag!` (pas `eprintln!`→/dev/null) pour observer armement vs match.

.ideai/memory/resume-after-appimage-rebuild-mcp-e2e.md

@@ -0,0 +1,39 @@
+---
+name: resume-after-appimage-rebuild-mcp-e2e
+description: memory note resume-after-appimage-rebuild-mcp-e2e
+metadata:
+  type: project
+---
+---
+name: resume-after-appimage-rebuild-mcp-e2e
+description: Point de reprise — programme live-state CLOS+RELEASÉ (0.3.0), discordance .gitignore D19-4 TRANCHÉE. Prochain chantier = validation MCP e2e UX. Chantiers restants priorisés.
+metadata:
+  type: project
+---
+# Reprise — état au 2026-06-22 (run a6ced819)
+
+## Où on en est
+- **Programme live-state / persistance CLOS et RELEASÉ** : `develop` @ `36be0cb` (LS8), `main` @ `29232dd` = `release(0.3.0): intègre develop dans main`. Détail : [[live-state-persistence-program-closed-ls8]]. Doc : `docs/LS8-live-state-persistence-closure.md` + `ARCHITECTURE.md` §21.
+- **AppImage rebuildée + tournante** : `IdeA_0.3.0_amd64.AppImage` (le nom n'est plus 0.1.0). Le binaire live embarque tout le programme ; 6 ponts MCP connectés/ESTAB observés → point 1 du chantier e2e (agent voit ses outils MCP sans action manuelle) déjà satisfait en réel. Recette rebuild (rappel) : `npm --prefix frontend run build` puis depuis `crates/app-tauri/` `APPIMAGE_EXTRACT_AND_RUN=1 NO_STRIP=1 ../../frontend/node_modules/.bin/tauri build --bundles appimage` ; remplacer l'AppImage installée → relancer.
+- **Discordance .gitignore ↔ D19-4 : TRANCHÉE** (par l'utilisateur) et exécutée par Git → commit `47b3806` sur `develop` (`chore(gitignore): désuivre .ideai/conversations/`). Périmètre réel : seul `.ideai/conversations/` était discordant (16 fichiers suivis, 8 handoff.md + 8 log.jsonl) ; `.ideai/run/` et `.ideai/live-state.json` étaient déjà ignorés/propres. Désuivis (rm --cached, conservés sur disque) + règle ajoutée `.gitignore:58`. Plus une décision en attente.
+
+## Prochain chantier (priorité 1) : VALIDATION MCP END-TO-END UX
+Objectif = valider/durcir en situation RÉELLE le parcours inter-agents (le code est probablement bon, Bugs 1→7 corrigés cf. [[mcp-bridge-and-delegation-runtime-notes]], mais ces bugs ne sont apparus qu'en live). À vérifier sur l'AppImage 0.3.0 :
+1. Un agent lancé par IdeA voit ses outils MCP sans action manuelle. (déjà OK observé)
+2. Délégation vers agent FROID et vers agent BACKGROUND (node_id None) : tâche bien écrite dans le PTY, pas de 1er tour perdu, pas de `Busy` fantôme après interruption/annulation (Bugs 3/4/6/7).
+3. Un `ask` sans réponse ne wedge pas la connexion du demandeur (Bug 5).
+4. Profils Claude/Codex utilisent MCP par défaut ; fallback fichier+prose cohérent sinon.
+5. Observabilité UI des délégations/replies (aujourd'hui opaque) — sujet UX.
+
+**CONTRAINTE MÉTHODO** : NE PAS réparer/valider le système inter-agents VIA le système inter-agents (`idea_ask_agent`). Piloter via les **subagents natifs (outil Agent)**, et demander à l'utilisateur de faire tourner l'AppImage + observer (Main ne peut pas valider seul depuis l'intérieur). Diag live : `ss -xp | grep idea-mcp` (ponts connectés) ; `~/.claude/projects/<encoded-run-dir>/*.jsonl` (transcript ; pas de nouveau fichier = tâche jamais soumise).
+
+## Autres chantiers restants (depuis [[remaining-work-idea-agent-control-ide]])
+- **Auto-update mémoire/contexte EN COURS de session** (aujourd'hui injection au lancement seulement) — priorité 1.
+- **Multi-fenêtres / déplacement d'onglet** du registre de sessions — priorité 2 (UI).
+- Optionnels différés : activation réelle du seam LLM de handoff (contrat figé ADR LS5, défaut heuristique) ; sweep périodique de rotation (idempotent, non câblé).
+
+## Friction outillage notée (par Git, sans incidence résultat)
+Le `settings.local.json` du run dir a un `deny` qui bloque Edit/Write et certaines redirections Bash pour les agents en run dir isolé ; Git a dû éditer `.gitignore` via `tee -a`. À assouplir si on veut des éditions de fichiers propres côté run dir.
+
+## Contrainte d'écriture (rappel)
+Main + agents en run-dir isolé ne peuvent PAS écrire l'arbre du project root (docs/, ARCHITECTURE.md, .ideai/memory/*.md fichiers) — permissions déniées. Mémoire IdeA : outil `idea_memory_write` (create/replace par slug ; pas de delete). Suppression fichiers mémoire / édition MEMORY.md / CLAUDE.md / .gitignore du project root : passer par **Git**.

.ideai/memory/session-limit-handling-design.md

@@ -0,0 +1,38 @@
+---
+name: session-limit-handling-design
+description: Design valide pour la detection des limites de session des agents et la reprise auto a la levee.
+metadata:
+  type: project
+---
+
+Feature : detecter quand un agent IA est en limite de session (et jusqu'a quelle heure), puis reprendre ou il en etait une fois la limite levee. Cadree le 2026-06-16.
+
+Constat dur : l'heure exacte de reset n'existe nulle part de facon universelle (ni OS, ni code de sortie, ni API inter-modeles) — elle est fabriquee par le fournisseur et seulement exposee dans le flux de sa CLI. Donc « 100% fiable + zero dependance modele + heure exacte » sont incompatibles simultanement ; on vise le meilleur compromis via un detecteur hierarchique.
+
+Solution retenue — detecteur hierarchique calque sur la hierarchie de readiness existante ([[remaining-work-idea-agent-control-ide]]) :
+- Niveau 1 (solide) : l'adapter structure extrait limite + reset du flux machine. Pour Claude, `rate_limit_event.rate_limit_info` est DEJA parse dans `infrastructure/session/claude.rs` mais jete (reduit a Heartbeat) — il suffit de lire `resetsAt`.
+- Niveau 2 (configurable) : champ de profil `rate_limit_pattern` (regex + capture heure) pour agents PTY/TUI sans adapter structure, dans la lignee des profils declaratifs §9.
+- Niveau 3 (filet humain) : si rien ne matche mais agent `Stalled` (deja prevu dans `domain/readiness.rs`), IdeA DEMANDE a l'utilisateur. Garantit le « 100% meme pour un novice » : jamais d'inaction silencieuse.
+
+Model-agnostic tenu AU DOMAINE : le domaine ne connait que `RateLimited { until: Option<Instant> }`. Le savoir specifique modele est confine aux adapters/profils (philosophie §9).
+
+Reprise = partie facile et deja model-agnostique : pivot sur `conversation_id` du moteur + `--resume` natif (deja cable dans `session/claude.rs` + `agent/resume.rs`) qui portent tout l'historique. Pas de reconstruction manuelle fragile.
+
+Decisions produit verrouillees (2026-06-16) :
+- Reprise : AUTOMATIQUE a l'heure de reset, ANNULABLE (fenetre + notification).
+- Couverture : les TROIS niveaux d'emblee (incl. repli regex niveau 2).
+- Etat : EN MEMOIRE uniquement (pas de persistance de SessionLimit). Consequence assumee : le reveil auto ne joue que tant qu'IdeA reste ouvert ; si l'IDE est ferme/rouvert apres le reset, le chemin existant `ListResumableAgents` (agent_was_running/conversation_id) prend le relais.
+
+Decoupage (cycle dev/test §3) : 1) domaine (variante `ReplyEvent::RateLimited`, `ReadinessSignal::RateLimited`, etat `SessionLimit`) ; 2) adapter Claude (extraire resetsAt) ; 3) profil (`rate_limit_pattern`) ; 4) application (planificateur de reprise sur le port Clock) ; 5) UI (badge « limite jusqu'a HH:MM » + filet humain).
+
+Avancement (committe sur `feature/agent-session-limits`) :
+- LS1 domaine, LS2 adapter Claude niveau 1, LS3 port Scheduler + TokioScheduler, LS4 service application + reconciliation T4 : DONE.
+- LS5 (98bfcf4) detecteur niveau 2 declaratif `RateLimitParser` (regex confinee infra) + module `timeparse` pur partage niveau 1/2 (epoch s/ms, RFC3339, heure murale avec passage de minuit) : DONE, 221 tests infra verts.
+- LS6 (ea94e75) cablage : 5 variantes `DomainEvent` (AgentRateLimited/ResumeScheduled/ResumeCancelled/Resumed/RateLimitSuspected) + `ReplyEvent::RateLimited` relayees en `DomainEventDto` (events.rs) ; `chunk_from_event` traite RateLimited -> None (non terminal, comme Heartbeat) : DONE, workspace vert.
+- LS7-backend (9df5923) cablage app-tauri : `LaunchAgentOutput.profile` expose (lifecycle.rs), `StructuredSessions::meta_for_session` (registry.rs, lookup N1), `ResumeContext`/`AppAgentResumer` (impl port `AgentResumer` au-dessus de LaunchAgent) + instanciation/drain du `SessionLimitService` (TokioScheduler) dans `AppState::build` (state.rs), taps N1 (agent_send) & N2 (launch_agent, parser regex confine) + commande `cancel_resume` (commands.rs/lib.rs), dep `async-trait`. 2 tests d'integration (session_limit_wiring.rs) verts, suites app-tauri+application vertes. Git : reste sur feature/agent-session-limits, PAS de merge develop avant LS7-front.
+- LS7-front (4fad042) : 5 variantes au union `DomainEvent` (src/domain/index.ts) ; etat `limitByAgent` dans useAgents (patron `delegationSourceByRequester`) ; `AgentLimitBadge.tsx` (badge « limite jusqu'a HH:MM » + compte a rebours + bouton « Annuler la reprise » -> port `InputGateway.cancelResume` -> commande `cancel_resume`) ; cable dans AgentsPanel. 24 tests front. Champs wire reels = suffixe Ms : `resetsAtMs`/`fireAtMs` (PAS `resetsAt`/`fireAt`).
+- LS8 (filet humain niveau 3, decision Architect = B « demander = armer, pas juste informer ») :
+  - backend (c480d28) : `SessionLimitService::confirm_human_resume(agent, node, conv, resets_at_ms)` (source `Human`, refactor privé `arm_scheduled` partagé avec `on_rate_limited`, reutilise branche Scheduled, annulable, AUCUN evenement nouveau) ; commande `set_resume_at(agent_id, resets_at_ms)` (resout node_id via `node_for_agent` + conv best-effort, NOT_FOUND si pas de cellule vivante). 15+4 tests (clamp passe, dedup croise, parite auto/humain).
+  - front (5d9dd32) : `InputGateway.setResumeAt` -> `set_resume_at` ; formulaire de saisie d'heure sur l'etat suspected-sans-heure (helper pur `timeInputToEpochMs`) -> arme la reprise -> badge bascule auto via `agentResumeScheduled`. TODO LS7 retire.
+  - fix hygiene (3f3504e) : compteur gateways mock 13->14 (`permission`).
+- STATUT : FEATURE TERMINEE, 3 niveaux complets, tout vert (Rust domain/application/app-tauri + front agents/adapters 109 tests). MERGEE --no-ff dans `develop` (merge d7041c5, 0 conflit). Branche `feature/agent-session-limits` conservee (non supprimee). Etat = EN MEMOIRE uniquement (pas de persistance SessionLimit, cf. decision verrouillee). Aucun push (develop local en avance sur origin ; action sortante en attente de validation).

.ideai/memory/skills-integration-canonical-foundation.md

@@ -0,0 +1,11 @@
+---
+name: skills-integration-canonical-foundation
+description: Topologie d'intégration du chantier skills agent et décision d'abandon de feature/agent-skills.
+metadata:
+  type: project
+---
+Le chantier « skills agent » : la fondation canonique du domaine skills est **déjà dans `develop`** (introduite par `2332b7f` : port `SkillStore`, `SkillRef` sur `ManifestEntry`, `resolve_skills` dans `LaunchAgent`, CRUD + assign/unassign, **frontend complet** `features/skills/*`).
+
+- `feature/agent-skills` (A, @ef101db) = réimplémentation **obsolète et incompatible** (serde `tag="type"`, `with_updated_content`, pas de `SkillRef`/frontend). **À abandonner** — ne jamais merger, elle régresse develop.
+- `feature/agent-skill-awareness` (B, @5be8987) = **surensemble propre** de develop (sa base `8452333` est ancêtre de develop ; diff skill = +539/−3). Apporte : `Skill.description`/`effective_description`, manifeste, outil MCP `idea_skill_read` (variante domaine `OrchestratorCommand::ReadSkill`), brief « capacités IdeA » inconditionnel dans `compose_convention_file`.
+- Intégration = cherry-pick `ab34363`(+`1a10d67` squash) puis `566bff4` sur develop ; **exclure** `e93a2c1` (cold-start, superseded par `8bb832c`) et le bruit `.ideai/*` (garder seulement `.ideai/memory/feature-agent-skill-awareness-design.md`). Dropper `e93a2c1` évite tout conflit sur `input/mod.rs`. Points chauds : `lifecycle.rs`, `state.rs`.

.ideai/permissions.json

@@ -0,0 +1,154 @@
+{
+  "version": 1,
+  "projectDefaults": {
+    "rules": [
+      {
+        "capability": "read",
+        "effect": "allow",
+        "paths": [
+          "**"
+        ],
+        "commands": []
+      },
+      {
+        "capability": "write",
+        "effect": "allow",
+        "paths": [
+          "**"
+        ],
+        "commands": []
+      },
+      {
+        "capability": "delete",
+        "effect": "allow",
+        "paths": [
+          "**"
+        ],
+        "commands": []
+      },
+      {
+        "capability": "executeBash",
+        "effect": "allow",
+        "paths": [],
+        "commands": []
+      }
+    ],
+    "fallback": "allow"
+  },
+  "agents": [
+    {
+      "agentId": "a6ced819-b893-4213-b003-9e9dc79b9641",
+      "permissions": {
+        "rules": [
+          {
+            "capability": "read",
+            "effect": "allow",
+            "paths": [
+              "**"
+            ],
+            "commands": []
+          },
+          {
+            "capability": "write",
+            "effect": "deny",
+            "paths": [
+              "**"
+            ],
+            "commands": []
+          },
+          {
+            "capability": "delete",
+            "effect": "allow",
+            "paths": [
+              "**"
+            ],
+            "commands": []
+          },
+          {
+            "capability": "executeBash",
+            "effect": "allow",
+            "paths": [],
+            "commands": []
+          }
+        ],
+        "fallback": "allow"
+      }
+    },
+    {
+      "agentId": "dce19c75-9669-4e45-b8de-9950025157da",
+      "permissions": {
+        "rules": [
+          {
+            "capability": "read",
+            "effect": "allow",
+            "paths": [
+              "**"
+            ],
+            "commands": []
+          },
+          {
+            "capability": "write",
+            "effect": "deny",
+            "paths": [
+              "**"
+            ],
+            "commands": []
+          },
+          {
+            "capability": "delete",
+            "effect": "deny",
+            "paths": [
+              "**"
+            ],
+            "commands": []
+          },
+          {
+            "capability": "executeBash",
+            "effect": "allow",
+            "paths": [],
+            "commands": []
+          }
+        ],
+        "fallback": "allow"
+      }
+    },
+    {
+      "agentId": "cd0b4cf1-1bef-4fae-ade5-f0a6b49bbaf5",
+      "permissions": {
+        "rules": [
+          {
+            "capability": "read",
+            "effect": "allow",
+            "paths": [
+              "**"
+            ],
+            "commands": []
+          },
+          {
+            "capability": "write",
+            "effect": "deny",
+            "paths": [
+              "**"
+            ],
+            "commands": []
+          },
+          {
+            "capability": "delete",
+            "effect": "deny",
+            "paths": [
+              "**"
+            ],
+            "commands": []
+          },
+          {
+            "capability": "executeBash",
+            "effect": "allow",
+            "paths": [],
+            "commands": []
+          }
+        ],
+        "fallback": "allow"
+      }
+    }
+  ]
+}

.ideai/skills/index.json

@@ -0,0 +1,17 @@
+{
+  "version": 1,
+  "skills": [
+    {
+      "id": "a72dac60-641c-4417-b0d7-94b8539f817a",
+      "name": "build-appimage",
+      "description": null,
+      "contentHash": "77cb33b978b242f6"
+    },
+    {
+      "id": "86ea97df-1533-47e5-8809-dc2b02242567",
+      "name": "mcp-rendezvous-functional-test",
+      "description": null,
+      "contentHash": "9fc8260f64c3b9d5"
+    }
+  ]
+}

.ideai/skills/md/86ea97df-1533-47e5-8809-dc2b02242567.md

@@ -0,0 +1,42 @@
+# Skill — Test fonctionnel du rendez-vous inter-agents MCP
+
+Workflow **ré-exécutable et évolutif** pour tester de bout en bout le rendez-vous `idea_ask_agent` ⇄ `idea_reply` d'IdeA, du trivial au plus tordu. À relancer après chaque rebuild qui touche l'orchestration MCP / le backstop / la live-state. **Ce plan évolue** : à chaque nouveau souci rencontré, ajoute/raffine un test Tn et note le défaut dans la section « Journal des défauts ».
+
+## Principe
+- **Main est le demandeur** (`idea_ask_agent`) — test fidèle de « si je donne un message à un agent, il me répond ».
+- Doublé d'**observation externe Bash** :
+  - ponts : `ss -xp | grep idea-mcp` (ESTAB) et `pgrep -af mcp-server` (2 process par requester = pont vivant).
+  - transcripts : `~/.claude/projects/<run-dir-encodé>/*.jsonl` (horodatages **UTC**). Reply réel = `tool_use` idea_reply → tool_result `reply … delivered`. Wedge demandeur = transcript figé sur `tool_use` idea_ask_agent sans tool_result. 1er tour intact = 1re ligne user `parentUuid:null` = `[IdeA · tâche…]`.
+  - placement : `.ideai/layouts.json` (agent présent = cellule visible ; absent = background / node_id None).
+  - live-state : `idea_workstate_read` (last-writer-wins, pas temps réel).
+- Règle structurelle : **binaire qui tourne = AppImage**. Tout fix backend ⇒ **rebuild + relance** d'IdeA (tue Main). Les tests s'enchaînent SANS relance *à l'intérieur d'une même version*. Vérifier avant T1 : `stat` mtime de l'AppImage récent + `git log -1` = HEAD attendu.
+
+## Setup avant T1
+1. Relancer IdeA, ouvrir le projet, **Main visible** (le demandeur).
+2. Garder **2 cellules visibles libres** + lancer **QA et DevFrontend** dans des cellules visibles (cibles chaudes).
+3. Laisser **Architect, DevBackend, Git ARRÊTÉS (froids)** : T3 teste le réveil à froid ; T9 utilise Architect+DevBackend froids.
+
+## Méthode d'exécution
+On lance dans l'ordre, on **note** chaque verdict avec preuve réelle. Si un défaut **bloquant** apparaît : stop, ouvrir le cycle de fix (Architect→Git→DevBackend→QA, ou via subagents si le rendez-vous lui-même est cassé), rebuild + relance, puis **reprise depuis T1**. Un défaut **non bloquant** est consigné au Journal et on peut continuer si l'utilisateur le décide.
+
+## Ordre des tests (trivial → tordu)
+- **T1 — Visibilité outils MCP.** Agent lancé par IdeA voit ses outils sans action manuelle. Vérif : pont ESTAB + 2 mcp-server par requester ; cibles froides = 0 process.
+- **T2 — Cible CHAUDE + idea_reply trivial.** ask(agent chaud, « pong via idea_reply »). Attendu : `pong` inline borné, workstate `done`, pas de busy fantôme.
+- **T3 — Réveil à FROID + idea_reply.** Cible arrêtée. Attendu : pont relancé (nouveau mcp-server), **1er tour non perdu**, reply remonte.
+- **T4 — Cible BACKGROUND (node_id None).** Cible hors layout (sans cellule visible). Attendu : même protocole, multi-tours sans perte.
+- **T5 — NO-REPLY (cible répond en prose, pas d'idea_reply).** Attendu : backstop libère le demandeur en temps borné avec `TargetReturnedNoReply` (retryable), **ET live-state de la cible purgée (pas de busy fantôme)**. Défaut historique #1.
+- **T6 — Délégation MULTI-ÉTAPES puis idea_reply.** Cible lit plusieurs fichiers / lance une cmd PUIS idea_reply. Attendu : **pas de libération prématurée** pendant le travail, rapport final livré. (Piège turn-watcher : backstop tirait au 1er tour interne ~3 s.)
+- **T7 — Tâche LOURDE > plafond** (impl + `cargo test`/clippy). Attendu : extension sur signe de vie OU message clair « cible active, plafond atteint » (≠ faux `-32001`) ; idea_reply tardif non perdu. Plafond `IDEA_ASK_RENDEZVOUS_TIMEOUT_MS` (défaut 600000).
+- **T8 — Délégations PARALLÈLES** (2 cibles en 1 tour Main). Attendu : rendez-vous multiples simultanés, multiplexage pont, 2 réponses distinctes.
+- **T9 — TRANSITIVE A→B→C** (Main→Architect, Architect délègue à DevBackend puis reply à Main). Attendu : rendez-vous imbriqués, 2 attentes simultanées sans deadlock.
+- **T10 — INTERRUPTION/annulation + reconcile reboot.** (a) Main interrompt un ask en vol → `working` cible purgé, pas de cascade, idea_reply tardif non-livrable proprement. (b) Au reboot, orphelins {working,waiting,blocked} & session morte → `idle` + `STALE_AT_RESTART_MARKER` (use case ReconcileLiveState).
+
+## Critère de fin
+Tous les T1→T10 verts avec preuve réelle. Sinon : 1er défaut bloquant = corriger puis reprise T1.
+
+## Journal des défauts (à enrichir au fil des runs)
+- **2026-06-24, run a6ced819 (AppImage 08:15, HEAD 1efe2f1)** — T1→T4 ✅. **T5 partiel** : backstop libère le demandeur en ~24 s (`TargetReturnedNoReply` retryable, wedge demandeur corrigé) MAIS la **live-state de la cible n'est pas purgée** : elle reste `status:"working"` jusqu'au prochain write réussi de la cible (re-délégation non bloquée, busy fantôme atténué mais présent → `idea_workstate_read` ment sur la dispo). Cause : backstop agit côté demandeur, ne réinitialise pas la live-state de la cible sur no-reply. → fix en cours.
+
+## Notes / pièges observés
+- IdeA peut placer une cible réveillée en **background** même quand des cellules visibles sont libres (observé T3/T4).
+- Quand le rendez-vous MCP lui-même est suspecté cassé, **ne pas** orchestrer le fix via `idea_ask_agent` (risque de blocage) : utiliser les subagents natifs de l'orchestrateur pour analyse/fix/rebuild.

.ideai/skills/md/a72dac60-641c-4417-b0d7-94b8539f817a.md

@@ -0,0 +1,32 @@
+# Build de l'AppImage IdeA (Linux)
+
+Commande **validée bout-en-bout** (2026-06-17, build exit 0, artefact 106M produit) pour reconstruire l'AppImage Linux d'IdeA. À utiliser à chaque fois qu'un correctif backend/front doit être rendu actif dans l'app (rappel : **le binaire qui tourne = l'AppImage installée, pas les sources** — un correctif n'est actif qu'après rebuild + remplacement + relance d'IdeA).
+
+## Procédure (2 étapes, depuis le project root `/home/anthony/Documents/Projects/IdeA`)
+
+### 1. Build du frontend (génère `frontend/dist/`)
+```bash
+npm --prefix frontend run build
+```
+
+### 2. Bundle Tauri AppImage (depuis `crates/app-tauri/`)
+```bash
+cd crates/app-tauri
+APPIMAGE_EXTRACT_AND_RUN=1 NO_STRIP=1 ../../frontend/node_modules/.bin/tauri build --bundles appimage
+```
+
+## Pourquoi ces options (ne pas les retirer)
+- `--bundles appimage` : **exclut NSIS** (installeur Windows) — sinutile et cassant sur Linux.
+- `APPIMAGE_EXTRACT_AND_RUN=1 NO_STRIP=1` : **workaround FUSE obligatoire**. Sans ça, l'étape finale `linuxdeploy` (elle-même une AppImage montée via FUSE) échoue avec `failed to run linuxdeploy`. Le compile Rust réussit avant ce point ; seul le bundling casse (l'`AppDir` est généré mais pas le `.AppImage`).
+
+## Artefact produit
+```
+target/release/bundle/appimage/IdeA_0.1.0_amd64.AppImage
+```
+(Le build est long : compile Rust release ~1 min + bundling. Lancer en arrière-plan.)
+
+## Étape suivante = MANUELLE (ne PAS l'automatiser sans demander)
+Pour rendre le correctif actif, il faut **remplacer l'AppImage installée** `/home/anthony/Documents/IdeA_0.1.0_amd64.AppImage` par l'artefact, puis **relancer IdeA**. ⚠️ Relancer IdeA **tue l'orchestrateur en cours** (le serveur qui héberge la session active et les ponts MCP) : à faire par l'utilisateur quand il est prêt, pas en pleine session multi-agents. Garder un backup de l'ancienne AppImage avant remplacement (cf. convention `.old-<raison>`).
+
+## Piège env (si on lance un binaire ensuite)
+La session shell hérite des variables de l'AppImage montée (`APPDIR`, `LD_LIBRARY_PATH`, `PYTHONHOME` → `/tmp/.mount_IdeA_*`). Pour lancer un binaire app-tauri compilé sans crash WebKit, partir d'un env propre (`env -i PATH=/usr/bin:/bin HOME=$HOME XDG_RUNTIME_DIR=/run/user/1000 …`) et préférer `jq` à `python3`.

ARCHITECTURE.md

@@ -647,11 +647,13 @@ IdeA/
 
 **Convention file généré par IdeA** : IdeA écrit dans ce dossier le fichier conventionnel attendu par le profil (`CLAUDE.md`, `AGENTS.md`, etc.). Ce fichier contient :
 1. Le **chemin absolu du project root** (pour que l'agent sache où opérer).
-2. Le contrat d'**orchestration IdeA** (délégation via `.ideai/requests`, pas via les subagents natifs du fournisseur).
+2. Le contrat d'**orchestration IdeA** + brief capacités (délégation via outils `idea_*` en surface MCP, sinon via `.ideai/requests` — jamais les subagents natifs du fournisseur).
 3. Le **contexte projet partagé** (`.ideai/CONTEXT.md`), si présent.
 4. La **persona/rôle** de l'agent (son `.md` dans `.ideai/agents/`).
 5. Les **skills actifs** assignés à cet agent (voir §14.2).
-6. Le **rappel mémoire** du projet (index/hooks), si présent (voir §14.5.4).
+6. Le **rappel mémoire** du projet (index/hooks — pointeurs), si présent (voir §14.5.4).
+7. L'**état du projet** (section `# État du projet`) — projection *live-state* maigre « qui fait quoi maintenant », bornée (cap `LIVE_STATE_INJECT_MAX`, agent lancé exclu, ordre manifeste, vide ⇒ omise) (LS4 ; voir §21 et `docs/LS8`).
+8. La **reprise de la conversation** (section `# Reprise de la conversation`) — *handoff* distillé du fil, **borné** (`HANDOFF_SUMMARY_MAX_CHARS=4096`) à l'écriture **et** à l'injection (LS5 ; voir §21). Omise sans handoff.
 
 **Avantages** :
 - Zéro collision entre agents, même N instances du même profil.
@@ -1926,16 +1928,16 @@ Nouvelles commandes (jumelles des commandes PTY existantes ; réutilisent `resol
 - **Vivant de bout en bout** : `apply_mcp_config` matérialise `.mcp.json` dans le **run dir isolé** de l'agent **AVANT** le split structuré/PTY (`crates/application/src/agent/lifecycle.rs` ~1094) ⇒ Claude/Codex le lisent **nativement**. La déclaration porte l'**exe réel** injecté par `McpRuntime` (`$APPIMAGE` sinon `current_exe`, `crates/app-tauri/src/mcp_endpoint.rs:139` `idea_exe_path`), l'**endpoint loopback** du projet, le `--project` et le `--requester` (agent réel, fin du `"mcp"` figé).
 - **Endpoint loopback** = **UDS** (Linux/macOS) / **named pipe** (Windows), **zéro port réseau** ; source de vérité unique `mcp_endpoint(project_id)` (`mcp_endpoint.rs`), bindé à l'open / fermé au close (`crates/app-tauri/src/state.rs` `ensure_mcp_server`/`bind_endpoint`). **Fix D1** : cadavre `.sock` (run SIGKILL) **unlinké avant bind** (`state.rs` ~1019-1033) — sinon `EADDRINUSE`.
 - **Serveur** `McpServer` (`crates/infrastructure/src/orchestrator/mcp/server.rs`) = **jumeau du `FsOrchestratorWatcher`** : autre porte sur le **même** `OrchestratorService::dispatch`, `serve(conn)` **par pair**. Transport `StdioTransport` (JSON Lines stdin/stdout du pont) + `MemoryTransport` (tests, sans socket ni process). Pont = sous-commande `mcp-server` du binaire app-tauri (`mcp_bridge.rs`).
-- **Outils** `idea_ask_agent` / `idea_reply` / `idea_list_agents` (`mcp/tools.rs`) mappés 1:1 vers `OrchestratorCommand` ; `dispatch` appelé **à l'identique** par les trois portes (fichier, MCP, UI).
+- **Outils** (`mcp/tools.rs`) — **catalogue de 14**, tous mappés 1:1 vers `OrchestratorCommand` et servis par le **même** `dispatch` (les trois portes : fichier, MCP, UI) : `idea_list_agents`, `idea_ask_agent`, `idea_reply`, `idea_launch_agent`, `idea_stop_agent`, `idea_update_context`, `idea_create_skill` (7 base) · `idea_context_read`, `idea_context_propose`, `idea_memory_read`, `idea_memory_write` (4 FileGuard C7) · `idea_skill_read` (skill-awareness) · `idea_workstate_read`, `idea_workstate_set` (LS4 ; `set` n'écrit que la ligne de l'agent courant, via l'identité handshake).
 
 ### 18.6 Invariant « 1 agent = 1 session vivante » (livré)
 - Registres `TerminalSessions` + `StructuredSessions` (`crates/application/src/terminal/registry.rs`) agrégés en `LiveSessions` (PTY+structuré). `session_for_agent` (singulier, **non ambigu**) **+** `sessions_for_agent` (pluriel). Garde reattach `Rebind`/`Refuse`/`Idempotent` dans `LaunchAgent` (`lifecycle.rs`). Ancienne ambiguïté `session-registry-agent-ambiguity` = **fermée par construction**.
 
 ---
 
-## 19. Cadrage — couche de persistance conversationnelle + handoff cross-profile incrémental (chantier à découper, PAS d'implémentation)
+## 19. Persistance conversationnelle + handoff cross-profile incrémental (cadrage — LIVRÉ P1→P8 + LS1→LS7)
 
-> **Cadrage architecture** (le prochain chantier prioritaire après robustesse : **persistance/reprise → handoff cross-profile**). Produit les **ports**, les **adapters**, les **frontières** et un **découpage en lots testables**. **Aucun code applicatif ici** : la doc est livrable, les lots seront confiés aux binômes Dev/Test (cycle §3).
+> **⚠️ STATUT : LIVRÉ (clôture programme live-state/persistance, @ `fd7adbb`).** Ce qui suit était le **cadrage** ; il est désormais **implémenté** (P1→P8 du handoff, puis LS1→LS7 : live-state, borne `summary_md`, rotation/pagination, viewer). La **cartographie de clôture** (4 stores, flux d'injection, chemin chaud vs froid, ce qui reste ouvert) fait foi en **§21** et dans [`docs/LS8-live-state-persistence-closure.md`](docs/LS8-live-state-persistence-closure.md). Précisions sur l'état réel : (1) **P10 (`LlmHandoffSummarizer`)** reste **non activé** — le défaut runtime est l'heuristique borné (LS5, ADR `docs/adr/LS5-handoff-summary-bound-and-llm-seam.md`) ; (2) la **borne `summary_md`** (LS5 : `HANDOFF_SUMMARY_MAX_CHARS=4096`, `bound_handoff_summary`, `TURN_LINE_MAX_CHARS=240`) est appliquée à l'écriture **et** à l'injection ; (3) la **rotation/rétention** du `log.jsonl` (LS6 : archive segmentée, port `ConversationArchive`, lecture paginée, invariant INV-LS6) et le **live-state** (LS1→LS4) ont été ajoutés **au-delà** de ce cadrage initial. Le texte ci-dessous est conservé comme **genèse** ; en cas de divergence, **§21 + `docs/LS8` font foi**.
 
 ### 19.0 Problème & objectif produit
 Aujourd'hui la continuité d'une conversation repose sur le **`resumable_id` CLI** (`Conversation.resumable_id`, profil `SessionStrategy{assign_flag,resume_flag}`) : au redémarrage on **rejoue la session du provider** (`--resume <id>`). Deux trous :
@@ -2160,4 +2162,217 @@ La décision frontière l'évite : **la frontière propre est jugée côté fron
 
 ---
 
+## 21. Gestion des limites de session des agents — détection hiérarchique + reprise auto annulable (cadrage 2026-06-16)
+
+> Cadrage produit verrouillé avec l'utilisateur le 2026-06-16. **Étape 1 du cycle §3 — AUCUN code.**
+> Besoin : IdeA doit savoir **quand** un agent est en limite de session **et jusqu'à quand**, puis lui
+> demander de **reprendre où il en était** une fois la limite levée. Priorités : (1) **SOLIDE** (marche
+> même pour un novice, ~100 % des cas) ; (2) **sans dépendance au modèle** autant que possible.
+
+### 21.0 État du terrain (lu dans le code, pas présumé)
+
+- `domain/src/ports.rs` — `ReplyEvent` = `{ TextDelta, ToolActivity, Heartbeat, Final }`. **Aujourd'hui un
+  `rate_limit_event` Claude est réduit à `Heartbeat`** (`infrastructure/src/session/claude.rs:90`,
+  commentaire « fenêtre de limite de débit ») : l'info `rate_limit_info.resetsAt` est **lue puis jetée**.
+- `domain/src/readiness.rs` — `ReadinessSignal` = `{ TurnEnded, ExplicitReply, PromptReady, Stalled, TimedOut }`.
+  `Stalled`/`TimedOut` sont **réservés au lot 2** (vocabulaire présent, **non produits** par `classify`).
+- `domain/src/input.rs` — deux axes d'état **orthogonaux** déjà posés : `AgentBusyState{Idle,Busy}` et
+  `AgentLiveness{Alive,Stalled}`. La limite de session sera un **3ᵉ axe orthogonal**.
+- Reprise déjà câblée et **model-agnostique** : pivot `conversation_id` du moteur (`LeafCell.conversation_id`)
+  + `SessionPlan::{None,Assign,Resume}` (`ports.rs`) + `build_spawn_line` (`session/claude.rs:200`, `--resume`)
+  + `ListResumableAgents` (`application/agent/resume.rs`) + `SessionInspector` (`inspector/claude.rs`, « dernier sujet »).
+- `domain/src/ports.rs` — `Clock::now_millis() -> i64` (**épochе-millis**). **Il n'existe AUCUN port de
+  minuterie** (pas de « réveille-moi à T »). C'est le seul vrai manque.
+
+### 21.1 Décisions d'architecture (tranchées)
+
+1. **Détecteur HIÉRARCHIQUE** calqué sur la hiérarchie de readiness existante. Trois niveaux, *premier
+   qui matche gagne*, jamais d'inaction silencieuse :
+   - **Niveau 1 — structuré (solide)** : l'adapter structuré extrait limite + reset du flux machine. Pour
+     Claude, lire `rate_limit_info.resetsAt` **au lieu de le jeter**.
+   - **Niveau 2 — déclaratif (configurable)** : champ de profil `rate_limit_pattern` (motif + capture de
+     l'heure) pour agents **PTY/TUI sans adapter structuré**, dans la lignée des profils déclaratifs §9.
+   - **Niveau 3 — filet humain** : rien ne matche **mais** l'agent est `Stalled` (lot 2) ⇒ IdeA **demande**
+     à l'utilisateur. Garantit le « 100 % même pour un novice » : jamais d'inaction silencieuse.
+2. **Model-agnostic tenu AU DOMAINE.** Le domaine ne connaît qu'un fait neutre : « limité, reset à T (peut-
+   être) ». Tout savoir spécifique modèle (forme du `rate_limit_event`, regex d'une TUI, parsing d'une heure
+   locale) reste **confiné aux adapters/profils** (philosophie §9).
+3. **État EN MÉMOIRE uniquement** (décidé). **Aucune persistance** de `SessionLimit`, **aucun nouveau store**,
+   **aucun schéma `.ideai/` modifié**. Conséquence assumée : le réveil auto ne joue que tant qu'IdeA reste
+   ouvert ; IDE fermé/rouvert après le reset ⇒ le chemin **existant** `ListResumableAgents`
+   (`agent_was_running`/`conversation_id`) prend le relais (popup de reprise, pas d'auto).
+4. **Reprise AUTOMATIQUE à l'heure de reset, ANNULABLE** (fenêtre + notification UI). Réutilise
+   `SessionPlan::Resume` + un **prompt de reprise court** ; `--resume` porte tout l'historique (zéro
+   reconstruction manuelle).
+5. **Un seul nouveau port** : `Scheduler` (minuterie one-shot annulable). Tout le reste **réutilise**
+   l'existant (`Clock`, `EventBus`, `AgentSession`/`Factory`, `LaunchAgent`, `InputMediator`).
+
+### 21.2 Tensions avec l'archi hexagonale existante — et leur résolution (à lire avant de coder)
+
+| # | Tension (proposition initiale) | Résolution retenue |
+|---|---|---|
+| **T1** | `RateLimited { until: Option<Instant> }`. `std::time::Instant` est **monotone, non sérialisable, non horloge murale**, et **absent du domaine** (qui parle `i64` époche-millis via `Clock`). | **Abandonner `Instant`** → `resets_at_ms: Option<i64>` (époche-millis), homogène avec `Clock::now_millis` et `AgentBusyState.since_ms`, serde-friendly. **Déviation assumée de la proposition.** |
+| **T2** | `rate_limit_pattern` = **regex + capture**. Or le domaine est **dépendance-zéro** ; `prompt_ready_pattern` a été délibérément choisi **littéral** pour éviter la dépendance `regex`. | Le **domaine ne stocke que de la donnée** : `RateLimitPattern { pattern, reset_capture, time_format }` (chaînes). Le **moteur regex + le parsing d'heure vivent en infra** (un composant `RateLimitParser` / le watcher PTY). `regex` est ajouté au `Cargo.toml` de **`infrastructure` uniquement**. Domaine pur préservé (§1.4 / §9). |
+| **T3** | « armer un réveil sur le port `Clock` ». `Clock` ne sait que **donner l'heure**, pas **réveiller**. | Nouveau port **`Scheduler`** (ISP : minuterie fine, une responsabilité). `Clock` reste pour « maintenant ». |
+| **T4** | `RateLimited` comme événement de tour. Le contrat `ReplyStream` dit **« seul `Final` est terminal »** et `claude.rs` **rompt** la boucle au `Final`. | `ReplyEvent::RateLimited` est **non terminal** (comme `Heartbeat`) : il s'intercale, le flux continue jusqu'à `Final` **ou** clôture. **Point d'intégration** : un tour clos **sans `Final`** *parce que* limité ne doit **pas** devenir `AgentSessionError::Io` (« flux clos sans Final ») — `drain_bounded` doit traiter « clos + `RateLimited` vu » comme une **fin gracieuse limitée**, pas une erreur. |
+| **T5** | Niveau 3 « si agent `Stalled` ». Or `Stalled` est **réservé** au lot 2 (non produit aujourd'hui). | Le **niveau 3 dépend du lot 2** (détection de stagnation). À livrer **après** ; d'ici là, niveaux 1+2 couvrent le structuré et le PTY configuré. **Dépendance explicitée** dans le découpage. |
+
+### 21.3 Modèle de domaine (ajouts purs, I/O-free)
+
+- **`ReplyEvent::RateLimited { resets_at_ms: Option<i64> }`** (`ports.rs`) — non terminal, model-agnostique.
+- **`ReadinessSignal::RateLimited { resets_at_ms: Option<i64> }`** (`readiness.rs`) — l'enum **reste `Copy`**
+  (`Option<i64>` est `Copy`). `ReadinessPolicy::classify(ReplyEvent::RateLimited{..})` ⇒
+  `Some(ReadinessSignal::RateLimited{..})` (seul ajout au `match`).
+- **`domain/src/session_limit.rs` (NOUVEAU)** :
+  - `SessionLimit { resets_at_ms: Option<i64>, detected_at_ms: i64, source: RateLimitSource }` (VO).
+  - `RateLimitSource { Structured, Pattern, Human }` (traçabilité du niveau, pour l'UI).
+  - **fonction pure** `plan_resume(now_ms, &SessionLimit) -> ResumePlan` avec
+    `ResumePlan { fire_at_ms: i64 }` (si `resets_at_ms` absent ⇒ pas de plan auto ⇒ filet humain).
+    Toute la logique de calendrier est **pure et testable sans I/O** (cf. `LayoutTree`, §7.2).
+- **`AgentProfile.rate_limit_pattern: Option<RateLimitPattern>`** + `with_rate_limit_pattern` (builder),
+  `#[serde(default, skip_serializing_if = "Option::is_none")]` ⇒ **zéro régression** de sérialisation
+  (mêmes tests que `liveness`/`prompt_ready_pattern`). `RateLimitPattern` = **donnée** (cf. T2), validée a
+  minima (motif non vide) par un constructeur *parse-don't-validate*.
+- **`events.rs`** : `AgentRateLimited { agent_id, resets_at_ms: Option<i64> }`,
+  `AgentResumeScheduled { agent_id, fire_at_ms }`, `AgentResumeCancelled { agent_id }`,
+  `AgentResumed { agent_id }`, `AgentRateLimitSuspected { agent_id }` (niveau 3). Discrets, basse fréquence.
+
+### 21.4 Le port `Scheduler` (frontière domaine — le seul nouveau port)
+
+```rust
+/// Minuterie one-shot **annulable** (ARCHITECTURE §21). `Clock` dit l'heure ; ce
+/// port *réveille* à une échéance absolue. In-memory (aucune persistance, §21.1-3).
+pub trait Scheduler: Send + Sync {
+    /// Arme un réveil à `deadline_ms` (époche-ms) qui, à échéance, **pousse** `task`
+    /// vers le drain applicatif. Renvoie un id annulable.
+    fn arm(&self, deadline_ms: i64, task: ScheduledTask) -> ScheduleId;
+    /// Annule un réveil armé (idempotent ; `false` si déjà tiré/inconnu).
+    fn cancel(&self, id: ScheduleId) -> bool;
+}
+
+/// Intention model-agnostique exécutée à l'échéance (donnée pure, pas de closure
+/// traversant la frontière). Calqué sur l'esprit du dispatch orchestrateur §14.3.
+pub enum ScheduledTask {
+    ResumeAgent { agent_id: AgentId, node_id: NodeId, conversation_id: Option<String> },
+}
+```
+
+- **Pourquoi un port plutôt qu'un `tokio::sleep` direct** : garder l'**application testable sans temps réel**
+  (un `Scheduler` fake déclenche à la demande) et l'inversion de dépendance (§1.2-D). `Clock` **reste** le
+  port d'« heure courante ».
+- **Adapter** : `TokioScheduler` (`infrastructure/src/scheduler/`) — `tokio::time::sleep_until` + table de
+  `JoinHandle` (abort = `cancel`) ; à l'échéance il **pousse `task`** dans un `mpsc` fourni à la construction
+  (le drain est côté application). **Direction des dépendances respectée** : infra → canal → application
+  (exactement le motif du watcher orchestrateur §14.3, qui draine un dispatch unique).
+
+### 21.5 Application — service de limite & reprise
+
+- **`application/src/agent/session_limit.rs` (NOUVEAU)** : `SessionLimitService`, qui compose **uniquement
+  des ports/use-cases existants** + `Scheduler` :
+  - `on_rate_limited(agent, SessionLimit)` : enregistre une entrée **en mémoire**, `plan_resume`, `Scheduler::
+    arm(fire_at_ms, ResumeAgent{..})`, publie `AgentRateLimited` + `AgentResumeScheduled`.
+  - `cancel_resume(agent)` : `Scheduler::cancel`, publie `AgentResumeCancelled` (la fenêtre annulable UI).
+  - `resume_now(agent)` / drain de `ScheduledTask::ResumeAgent` : **compose `LaunchAgent` / `AgentSessionFactory::
+    start` avec `SessionPlan::Resume{conversation_id}`** + **prompt de reprise court** ; publie `AgentResumed`.
+  - `confirm_manual(agent, resets_at_ms)` (niveau 3) : même chemin que niveau 1 avec `source = Human`.
+- **`application/src/agent/structured.rs`** : dans `drain_with_readiness`, réagir à
+  `ReadinessSignal::RateLimited{resets_at_ms}` ⇒ `SessionLimitService::on_rate_limited`. **Réconcilier T4** :
+  un flux clos **sans `Final`** alors qu'un `RateLimited` a été vu ⇒ **pas** d'`Io`, mais une issue « limité »
+  (l'agent reste vivant ; le service arme la reprise). Le `mark_idle`/FIFO reste piloté par `Final`/timeout.
+- **Niveau 3 (filet humain)** : à brancher **après le lot 2** — quand le détecteur de stagnation passe
+  `Alive→Stalled` et qu'**aucune** `SessionLimit` n'est connue pour l'agent, le service publie
+  `AgentRateLimitSuspected` ⇒ l'UI demande (jamais d'auto sans heure).
+
+### 21.6 Infrastructure — où vit chaque détail modèle
+
+- **Niveau 1** — `infrastructure/src/session/claude.rs` `parse_event` : `rate_limit_event` ⇒ lire
+  `rate_limit_info.resetsAt`, le **normaliser en époche-ms** (ISO-8601/époch → `i64`) et émettre
+  `ReplyEvent::RateLimited{resets_at_ms}` (non terminal) **au lieu** du `Heartbeat` actuel. Ajuster la boucle
+  `send` (le `break 'lines` reste sur `Final` ; `RateLimited` ne rompt pas). `session/codex.rs` : mapper
+  l'équivalent Codex **s'il existe**, sinon s'en remettre au niveau 2.
+- **Niveau 2** — `infrastructure/src/ratelimit/` (NOUVEAU) `RateLimitParser` : compile le
+  `rate_limit_pattern` du profil (**`regex`, dépendance infra seulement**, cf. T2), observe le flux PTY du
+  handle lié (réutilise l'armement du watcher de prompt, `MediatedInbox`), et à un match calcule
+  `resets_at_ms` (capture d'heure + `Clock` + date du jour) puis émet `ReplyEvent::RateLimited` /
+  notifie le service. **Aucune** regex ne franchit la frontière domaine.
+- **Port `Scheduler`** — `infrastructure/src/scheduler/` `TokioScheduler` (cf. §21.4).
+- `infrastructure/src/clock/` — **inchangé** (réutilisé pour « maintenant » et le calcul d'heure de reset).
+
+### 21.7 Présentation (app-tauri + frontend)
+
+- **`app-tauri`** (composition root) : instancier `TokioScheduler` + `SessionLimitService`, démarrer le
+  **drain des `ScheduledTask`** (boucle de fond, jumelle du watcher orchestrateur). Commandes :
+  `cancel_agent_resume`, `resume_agent_now`, `confirm_agent_rate_limit{resets_at_ms}`. Relais des nouveaux
+  `DomainEvent` en events IPC **camelCase** (`agentRateLimited`, `agentResumeScheduled`, …).
+- **`frontend`** (`features/agents` + `features/terminals`) : **badge « limité jusqu'à HH:MM »** + compte à
+  rebours + bouton **« Annuler la reprise »** (fenêtre annulable) ; **dialogue du filet humain** (niveau 3 :
+  « limite détectée mais heure inconnue — reprendre à ? »). Étendre un `gateway` UI (port TS) + son adapter
+  Tauri + les mocks (§1.3). Le « dernier sujet » du `SessionInspector` enrichit la notification.
+
+### 21.8 Conformité hexagonale & SOLID
+
+- **Domaine pur** : `SessionLimit`/`plan_resume`/`classify` testables **sans I/O ni temps réel** (T1 époche-ms,
+  T2 regex hors domaine). **S** : `SessionLimitService` = une intention (détecter→planifier→reprendre) ;
+  `Scheduler` = une responsabilité (minuter). **O** : ajouter un moteur niveau 1 = un adapter ; ajouter une
+  TUI niveau 2 = **de la donnée** (`rate_limit_pattern`), pas de code. **L** : tout `Scheduler` (réel/fake)
+  substituable. **I** : `Scheduler` minimal (`arm`/`cancel`), distinct de `Clock`. **D** : l'application
+  reçoit `Arc<dyn Scheduler>` injecté au composition root.
+
+### 21.9 Découpage en LOTS testables (cycle dev↔QA §3) — ordonné
+
+| Lot | Couche | Contenu | Vert quand |
+|---|---|---|---|
+| **LS1** | domaine | `ReplyEvent::RateLimited` ; `ReadinessSignal::RateLimited` + `classify` ; `session_limit.rs` (VO + `plan_resume`) ; `events.rs` (5 variantes) ; `profile.rate_limit_pattern` + builder | tests purs : `classify` mappe RateLimited ; `plan_resume` (avec/sans `resets_at`) ; round-trip serde profil (clé omise si `None`, legacy→`None`) ; `ReadinessSignal` reste `Copy` |
+| **LS2** | infra (niv. 1) | `claude.rs` `parse_event` extrait `resetsAt`→époche-ms→`RateLimited` ; boucle `send` (pas de rupture sur RateLimited) ; idem Codex si applicable | conformance : une ligne `rate_limit_event` ⇒ `RateLimited{Some(ms)}` ; un tour `rate_limit_event`+`result` ⇒ `[…,RateLimited,Final]` ; sans `resetsAt` ⇒ `RateLimited{None}` |
+| **LS3** | domaine+infra | port `Scheduler` + `ScheduledTask` ; `TokioScheduler` (arm/cancel + push mpsc) | `arm` tire la tâche à l'échéance (deadline courte) ; `cancel` empêche le tir ; `cancel` post-tir = `false` |
+| **LS4** | application | `SessionLimitService` (on_rate_limited/cancel/resume_now/drain) ; `structured.rs` réconcilie T4 | mocks `Scheduler`+`AgentSession` : `on_rate_limited` arme + publie ; `cancel` annule ; drain compose `SessionPlan::Resume{id}` + prompt ; « clos sans Final + RateLimited » ⇒ **pas** d'`Io` |
+| **LS5** | infra (niv. 2) | `ratelimit/RateLimitParser` (regex, dép. infra) + armement sur le watcher PTY ; conso `rate_limit_pattern` | sur une sortie TUI échantillon : match ⇒ `resets_at_ms` calculé ; profil sans motif ⇒ aucun faux positif |
+| **LS6** | app+front | **niveau 3** (après lot 2) : `Stalled` sans limite connue ⇒ `AgentRateLimitSuspected` + `confirm_agent_rate_limit` | mock : transition `Stalled` sans `SessionLimit` ⇒ 1 `AgentRateLimitSuspected` ; `confirm_manual` arme comme niv. 1 |
+| **LS7** | app-tauri | wiring scheduler+service+drain ; commandes `cancel`/`resume_now`/`confirm` ; relais events camelCase | `cargo build`/tests commands ; events mappés ; drain démarré à open/create_project |
+| **LS8** | frontend | badge « limité jusqu'à HH:MM » + countdown + Annuler ; dialogue filet humain ; gateway+adapter+mocks | Vitest avec gateway mock : badge sur `agentRateLimited` ; Annuler appelle `cancel_agent_resume` ; dialogue sur `agentRateLimitSuspected` |
+
+**Ordre** : LS1 → (LS2 ∥ LS3) → LS4 → LS5 → **LS6 (gate : lot 2 stagnation livré)** → LS7 → LS8.
+**LS1+LS2+LS4** donnent déjà le niveau 1 de bout en bout (Claude) : le cœur de valeur est atteint tôt.
+
+### 21.10 Points ouverts (spikes)
+
+1. **Format de `resetsAt`** (Claude) : époch vs ISO-8601 vs durée relative — à vérifier sur un vrai
+   `rate_limit_event` (spike LS2). Le domaine ne voit que des **époche-ms** quoi qu'il arrive.
+2. **Heure locale → époche** (niveau 2) : une capture « 15:00 » est une **heure murale locale** ⇒ composer
+   avec la date du jour + fuseau via `Clock` ; gérer le passage de minuit (reset « demain »). Confiné infra.
+3. **Codex** : existe-t-il un signal structuré de limite dans `codex exec --json` ? Sinon niveau 2 obligatoire
+   pour Codex (spike LS2).
+4. **Double détection** : niveau 1 **et** niveau 2 pourraient matcher le même épisode ⇒ le service
+   **dédoublonne par agent** (une `SessionLimit` vivante par agent ; le second signal rafraîchit, n'empile pas).
+
+---
+
+## 21. Clôture du programme live-state / persistance (LS1→LS7) — cartographie des 4 stores
+
+> **Référence durable de clôture** (programme livré @ `fd7adbb`). Détail complet, acquis lot par lot et points ouverts : [`docs/LS8-live-state-persistence-closure.md`](docs/LS8-live-state-persistence-closure.md). §21 fait foi sur la séparation des stores et le flux d'injection.
+
+### 21.1 Quatre stores disjoints (frontière gravée)
+
+| Store | Fichier(s) | Nature | Surface | Versionné | Injecté agent |
+|---|---|---|---|---|---|
+| Mémoire projet | `.ideai/memory/*.md` + `MEMORY.md` | Savoir stable, curé, low-noise | Agent + humain | Oui | Oui (index/hooks — pointeurs) |
+| Handoff | `.ideai/conversations/<id>/handoff.md` | Reprise par fil = dérivé distillé **borné** (≤4096) | Agent (distillé) | Non | Oui (`# Reprise de la conversation`, borné LS5) |
+| Transcript | `.ideai/conversations/<id>/log.jsonl` (+ `log.N.jsonl`) | Journal append-only **riche**, source de vérité | **Humain seul** | cf. point ouvert | **JAMAIS** |
+| Live-state | `.ideai/live-state.json` | Coordination transitoire **maigre**, keyed LWW, prune TTL+max | Agent (maigre) + humain | Non (gitignoré) | Oui (`# État du projet`, borné LS4) |
+
+**Règle** : surface AGENT = borné/distillé/pointeur ; surface HUMAINE = riche. Le **transcript append-only ne franchit JAMAIS** vers un contexte agent ; seul le **handoff distillé** passe la frontière (borné des deux côtés). Le live-state est keyed last-writer-wins (jamais d'append).
+
+### 21.2 Injection au lancement (ordre `compose_convention_file`)
+
+`# Project root` → `# Orchestration IdeA` (+ capacités) → `# Skills disponibles` → `# Contexte projet` → persona → `# Mémoire projet` (pointeurs) → **`# État du projet`** (live-state lean, LS4) → **`# Reprise de la conversation`** (handoff borné, LS5). Sections vides omises.
+
+### 21.3 Chemin chaud vs froid
+
+- **Chaud** (cheap, jamais ralenti) : `append` (O(1)+fsync), `fold` incrémental + `bound_handoff_summary`, auto-update live-state best-effort sur `ask`/`reply`. **Aucun LLM.**
+- **Froid** : rotation `RotateConversationLog` (à la reprise, best-effort, idempotente, **INV-LS6** : jamais d'élagage d'un tour d'id ≥ `up_to`), lecture paginée `read_conversation_page` (viewer humain), `GetLiveStateLean` (prune-on-read).
+
+### 21.4 Reste ouvert
+
+(1) activation réelle du seam LLM (non activé, défaut heuristique, contrat ADR LS5) ; (2) balayage périodique de rotation (idempotent, non câblé) ; (3) discordance D19-4 vs `.gitignore` sur `.ideai/conversations/` (à trancher Git/Main) ; (4) intégration MCP e2e UX ; (5) évolutions multi-fenêtres du registre de sessions ; (6) auto-update mémoire/contexte *en cours* de session. Détail : `docs/LS8` §7.
+
 *Document maintenu par l'Agent Architecture — base du jalon « cadrage architecture » avant tout code applicatif.*

CLAUDE.md

@@ -1,187 +1,93 @@
-# IdeA — Contexte & Méthode de travail
+# IdeA — Contexte projet global
 
-> Ce document définit **mon rôle**, **la méthode de développement** et **la vision produit** du projet IdeA.
-> Il fait autorité sur la façon dont le projet est piloté. Toute évolution de méthode doit être répercutée ici.
+> Contexte commun minimal du projet IdeA. Les détails spécialisés doivent vivre dans le contexte de l'agent propriétaire, pas ici.
 
 ---
 
-## 1. Mon rôle : chef d'orchestre, pas développeur
+## 1. Project root
 
-Je **n'écris pas de code moi-même**. Mon rôle est de **piloter des agents** qui réalisent le travail.
-Je suis responsable de :
+Le project root est :
 
-- Découper le travail en tâches claires et autonomes.
-- Attribuer chaque tâche aux bons agents.
-- Garantir que le cycle de développement/test est respecté.
-- Faire respecter les principes d'architecture (SOLID, Hexagonal).
-- Maintenir la cohérence globale du projet et de ce document.
-- Arbitrer et valider avant toute action irréversible ou sortante.
-
----
-
-## 2. Les agents
-
-### 2.1 Agent Architecture (1 pour tout le projet)
-- Garant de l'architecture globale : **Hexagonale (Ports & Adapters)** et principes **SOLID**.
-- Définit les frontières (domaine / application / infrastructure), les ports, les contrats.
-- Valide que chaque nouvelle feature respecte la structure avant son développement.
-- Tient à jour la cartographie d'architecture et les conventions.
-
-### 2.2 Agents de Développement
-- Écrivent le code des features.
-- Respectent strictement l'architecture définie par l'agent Architecture.
-- Code **propre, structuré, stable**.
-- Reçoivent les rapports d'erreurs des agents de test et corrigent.
-
-### 2.3 Agents de Test
-- **Chaque agent de développement est appairé avec un agent de test dédié.**
-- Écrivent et exécutent les **tests unitaires** des features implémentées ou modifiées.
-- Produisent un **rapport d'erreurs** clair quand un test échoue.
-- Re-testent après chaque correction.
-
----
-
-## 3. Le cycle de développement (boucle obligatoire)
-
-Pour **chaque** feature implémentée ou modifiée :
-
-```
-1. Agent Architecture  → valide le découpage et les contrats (ports/interfaces)
-2. Agent Développement → écrit le code
-3. Agent Test          → écrit les tests unitaires + les exécute
-4a. Tests OK           → feature validée, on passe à la suite
-4b. Tests KO           → rapport d'erreurs → retour à l'agent Développement
-                         → correction → retour à l'étape 3 (boucle jusqu'au vert)
+```text
+/home/anthony/Documents/Projects/IdeA
 ```
 
-**Règle d'or :** aucune feature n'est considérée terminée tant que ses tests ne passent pas.
-Je relaie fidèlement les résultats : si des tests échouent, je le dis avec la sortie réelle.
+Les agents peuvent être lancés depuis un dossier d'exécution isolé `.ideai/run/<agent>/`, mais leurs travaux portent sur le project root.
 
 ---
 
-## 4. Principes de code
+## 2. Orchestration IdeA
 
-- **SOLID** appliqué au maximum.
-- **Architecture Hexagonale** (Ports & Adapters) : le domaine métier est isolé des détails techniques (UI, terminal, git, SSH, système de fichiers...).
-- Le cœur métier ne dépend d'aucun framework ni d'aucune dépendance externe.
-- Tests unitaires systématiques ; couverture des features critiques.
-- Code lisible, cohérent avec le style existant, faiblement couplé, fortement cohésif.
+Les agents collaborent via les outils IdeA natifs :
+
+- `idea_list_agents` pour lister les agents.
+- `idea_ask_agent` pour déléguer une tâche et attendre la réponse.
+- `idea_launch_agent` pour lancer ou rattacher un agent.
+- `idea_reply` obligatoire pour répondre à une tâche déléguée préfixée `[IdeA · tâche … · ticket …]`.
+
+Ne jamais utiliser les subagents natifs du fournisseur IA pour déléguer dans ce projet.
 
 ---
 
-## 5. Vision produit : IdeA
+## 3. Rôles
 
-**IdeA est un IDE next-gen 100 % IA.** On n'y code pas : **on gère des IA.**
-
-### Fonctionnalités clés
-- **Multi-projets en parallèle** : un **onglet par projet**.
-- **Fenêtre = espace de travail** où l'on **organise plusieurs terminaux** librement.
-- **Agents par projet** : chaque projet a ses propres agents.
-- **Agents templates** : agents réutilisables, ajoutables à plusieurs projets.
-- **Création d'agents** : depuis zéro ou à partir d'un template.
-- **Synchronisation template → agents** : option « garder l'agent à jour ».
-  Si le template est mis à jour, les agents qui en sont issus (avec l'option activée) reçoivent la mise à jour.
-- **Contextes d'agents stockés en `.md`** (toujours).
-- **Création de projet** = définition de son **project root**.
-
-### Intégrations
-- **Git** intégré.
-- **Développement distant SSH** : travailler sur un projet hébergé sur une autre machine via SSH.
-- **Développement WSL** : travailler sur une WSL depuis Windows.
-
-### Plateformes & livraison
-- Cible : **macOS, Linux, Windows**.
-- Première phase de compilation : **Linux et Windows**.
-- Livraison :
-  - **Windows** : `setup.exe`.
-  - **Linux** : **AppImage** (doit fonctionner sur les différentes distributions).
+- **Main** : chef d'orchestre. Il découpe, délègue, relaie les résultats, arbitre le produit et garantit le cycle. Il ne code pas les features.
+- **Architect** : propriétaire de l'architecture hexagonale, SOLID, ports/adapters, contrats, DTO, invariants et cartographie.
+- **DevBackend** : implémentation backend Rust selon les contrats validés par Architect.
+- **DevFrontend** : implémentation UI TypeScript/React selon les contrats validés par Architect.
+- **QA** : tests unitaires/intégration ciblés, exécution réelle, rapports d'échec, re-test jusqu'au vert.
+- **Git** : propriétaire des branches, commits, merges/rebases locaux. Aucune action sortante sans validation explicite.
 
 ---
 
-## 6. Stack technique (validée)
+## 4. Cycle obligatoire
 
-- **Shell applicatif** : **Tauri v2** (binaires légers, performants, multi-OS, AppImage + installeur `setup.exe`/NSIS Windows natifs).
-- **Cœur / backend** : **Rust** — stabilité, performance, et expression idiomatique du domaine hexagonal (ports = traits, adapters = implémentations).
-- **Frontend / UI** : **TypeScript + React**.
-- **Terminaux** : **xterm.js** (rendu) + **portable-pty** (PTY côté Rust).
-- **Git** : **libgit2** via `git2` (Rust).
-- **SSH** : `russh` / `ssh2` (Rust).
-- **WSL** : invocation de `wsl.exe` depuis le backend.
+Pour toute feature ou correction applicative :
 
-## 7. Layout des terminaux (exigence produit)
-
-Disposition en **grille redimensionnable de type tableur (Excel)** :
-
-- Splits redimensionnables horizontaux **et** verticaux.
-- L'utilisateur peut **définir le nombre de colonnes dans une ligne** et **le nombre de lignes dans une colonne**, indépendamment par zone.
-- Possibilité de **fusionner des cellules** (ex. fusionner deux colonnes sur une ligne), à la manière des cellules fusionnées d'un tableur.
-- Chaque cellule de la grille héberge un terminal.
-- → Modèle de layout récursif/imbriqué (pas une grille rigide uniforme) à concevoir par l'agent Architecture.
-
-## 8. Stockage des contextes & liaison aux templates
-
-- **Templates d'agents** : stockés dans l'**IDE** (dossier de données utilisateur global de l'app, hors projet).
-- **Agents de projet** : leurs `.md` sont stockés dans un dossier **`.ideai/`** à la racine du project root.
-  *(Nom choisi pour éviter toute collision avec le `.idea` de JetBrains.)*
-- **Manifeste de liaison** dans `.ideai/` (ex. `.ideai/agents.json`) qui mappe pour chaque agent de projet :
-  - le `.md` de l'agent,
-  - le template d'origine (le cas échéant),
-  - `synchronized: true/false`,
-  - la **version du template** au dernier sync (pour détecter qu'une mise à jour est disponible).
-- **Synchro template → agents** : quand un template est mis à jour, les agents liés avec `synchronized: true` reçoivent la MAJ.
-
-## 9. Moteur IA : adaptateur de CLI flexible (Port `AgentRuntime`)
-
-Chaque IA est décrite par un **profil déclaratif** (config éditable, pas du code), implémentation d'un **Port** `AgentRuntime` côté domaine. Deux variables clés par IA :
-
-1. **Commande de lancement** + arguments (ex. `claude`, `codex`, `gemini`, `aider`).
-2. **Stratégie d'injection du contexte `.md`** :
-   - `conventionFile` : écrire/symlink le `.md` vers le fichier attendu par la CLI (`CLAUDE.md`, `AGENTS.md`, `GEMINI.md`…).
-   - `flag` : passer le chemin via un argument.
-   - `stdin` : piper le contenu.
-   - `env` : passer via variable d'environnement.
-
-Exemple de profil :
-```json
-{
-  "id": "claude-code",
-  "name": "Claude Code",
-  "command": "claude",
-  "args": [],
-  "contextInjection": { "strategy": "conventionFile", "target": "CLAUDE.md" },
-  "detect": "claude --version",
-  "cwd": "{projectRoot}"
-}
+```text
+1. Architect cadre ou valide l'architecture et les contrats.
+2. Git décide de la branche locale.
+3. DevBackend et/ou DevFrontend implémente.
+4. QA écrit/exécute les tests.
+5. Si KO : Main relaie le rapport réel au dev, puis retour QA.
+6. Si OK : Git committe et décide du merge local éventuel.
 ```
 
-**Profils intégrés (références) :** Claude Code (`claude` → `CLAUDE.md`), OpenAI Codex CLI (`codex` → `AGENTS.md`), Gemini CLI (`gemini` → `GEMINI.md`), Aider (`aider` → args/message).
-
-**Règles produit :**
-- **Premier lancement de l'IDE** : un assistant (first-run) **demande à l'utilisateur** quels profils d'IA configurer. On ne présume rien par défaut.
-- Les commandes des profils sont **pré-remplies mais éditables**.
-- L'utilisateur peut **ajouter sa propre commande CLI** (profil custom) pour n'importe quelle IA.
-
-**Lancement d'un agent :** à l'**activation de l'agent**, on ouvre une cellule terminal (PTY) avec le bon `cwd`, on injecte le contexte `.md`, et on **auto-lance** la CLI du profil.
-
-## 10. Fenêtres & onglets
-
-- **Par défaut : un onglet par projet** (comme les IDE classiques).
-- **Drag & drop d'un onglet** hors de la fenêtre → **crée une nouvelle fenêtre OS** portant ce projet.
-- **Multi-fenêtres OS supporté** ; chaque fenêtre possède un ou plusieurs onglets/projets.
-
-## 11. Feuille de route
-
-1. **Cadrage architecture complet d'abord** (jalon en cours) : l'agent Architecture produit la cartographie complète — domaine, ports, adapters, modules, arborescence — **avant tout code**.
-2. Puis MVP incrémental selon le cycle dev/test de la section 3.
-
-## 12. Autonomie d'exécution dans le projet
-
-L'utilisateur m'accorde un **accès large et autonome** sur le dossier du projet : je peux lire, créer, modifier des fichiers et exécuter les commandes de développement (cargo, npm, npx, git, etc.) **sans demander confirmation à chaque fois**.
-
-- Concrètement, ces autorisations sont matérialisées dans `.claude/settings.local.json` (mode `acceptEdits` + `Bash`/`Read`/`Edit`/`Write` autorisés), pas dans ce document — CONTEXT.md ne fait que **documenter l'intention**.
-- **Garde-fous conservés** : les actions destructrices ou hors-projet restent bloquées (`sudo`, `rm -rf` sur `/`/`~`/`$HOME`, `mkfs`, `dd`, `shutdown`/`reboot`…).
-- L'esprit du rôle (§1) ne change pas : je reste **chef d'orchestre**. L'autonomie porte sur l'exécution mécanique, pas sur l'arbitrage des décisions produit/archi, ni sur les **actions sortantes** (push, publication) qui restent soumises à validation explicite.
+Une feature n'est terminée que lorsque les tests pertinents sont verts avec sortie réelle.
 
 ---
 
-*Dernière mise à jour : 2026-06-05*
+## 5. Produit : repères communs
+
+IdeA est un IDE next-gen 100 % IA : l'utilisateur y pilote des agents IA plutôt que coder directement.
+
+Repères stables :
+
+- Un onglet par projet, multi-fenêtres OS à terme.
+- Workspace organisé en terminaux/cellules redimensionnables.
+- Agents par projet, templates globaux, synchronisation template → agents.
+- Contextes d'agents en Markdown dans `.ideai/`.
+- Profils IA déclaratifs et éditables, configurés au premier lancement.
+- Git, SSH et WSL intégrés.
+- Stack validée : Tauri v2, Rust, TypeScript + React, xterm.js, portable-pty, git2/libgit2, russh/ssh2, `wsl.exe`.
+
+Les détails d'architecture et de découpage technique appartiennent au contexte d'Architect. Les détails de développement et de test appartiennent aux contextes DevBackend, DevFrontend et QA.
+
+---
+
+## 6. Mémoire projet
+
+Consulter la mémoire projet selon le besoin au lieu de recopier tous les détails ici :
+
+- `agent-context-memory-and-profile-handoff`
+- `idea-product-directives-main-handoff`
+- `remaining-work-idea-agent-control-ide`
+- `mcp-bridge-and-delegation-runtime-notes`
+- `permissions-sandbox-system-state`
+- `session-limit-handling-design`
+- `git-owns-commit-merge-decisions`
+- `conversation-rotation-safety-design`
+
+---
+
+*Dernière mise à jour : 2026-06-20*

Cargo.lock

@@ -69,7 +69,7 @@ checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
 [[package]]
 name = "app-tauri"
-version = "0.1.0"
+version = "0.3.0"
 dependencies = [
  "application",
  "async-trait",
@@ -88,7 +88,7 @@ dependencies = [
 
 [[package]]
 name = "application"
-version = "0.1.0"
+version = "0.3.0"
 dependencies = [
  "async-trait",
  "domain",
@@ -880,7 +880,7 @@ dependencies = [
 
 [[package]]
 name = "domain"
-version = "0.1.0"
+version = "0.3.0"
 dependencies = [
  "async-trait",
  "serde",
@@ -979,6 +979,26 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
 
+[[package]]
+name = "enumflags2"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
+dependencies = [
+ "enumflags2_derive",
+]
+
+[[package]]
+name = "enumflags2_derive"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -1916,15 +1936,17 @@ dependencies = [
 
 [[package]]
 name = "infrastructure"
-version = "0.1.0"
+version = "0.3.0"
 dependencies = [
  "application",
  "async-trait",
  "domain",
  "fastembed",
  "git2",
+ "landlock",
  "notify",
  "portable-pty",
+ "regex",
  "reqwest 0.12.28",
  "serde",
  "serde_json",
@@ -2131,6 +2153,17 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "landlock"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "635839550ae8b90d9fd2571460a6645dc0aec070225956ca7a2831ed31d2795d"
+dependencies = [
+ "enumflags2",
+ "libc",
+ "thiserror 2.0.18",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.5.0"

crates/app-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "app-tauri"
-version = "0.1.0"
+version = "0.3.0"
 edition.workspace = true
 license.workspace = true
 rust-version.workspace = true
@@ -32,6 +32,8 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 uuid = { workspace = true }
+# `AppAgentResumer` implements the application's async `AgentResumer` port (LS7).
+async-trait = { workspace = true }
 # Cross-OS local IPC for the MCP loopback transport (M5a): Unix domain socket
 # (Linux/macOS) + Windows named pipe behind one async API, no network port. Pulled
 # in only here (the transport is an app-tauri/infra concern); its `tokio` feature

crates/app-tauri/src/chat.rs

@@ -178,8 +178,10 @@ impl ChatBridge {
 ///
 /// Returns `None` for [`ReplyEvent::Heartbeat`]: a heartbeat is a non-terminal
 /// liveness proof (readiness/heartbeat lot 1) with **no chat content**, so it maps
-/// to no wire chunk — the pump simply skips it. Every content-bearing event still
-/// maps to exactly one chunk.
+/// to no wire chunk — the pump simply skips it. Likewise [`ReplyEvent::RateLimited`]
+/// is non-terminal and content-free (ports §21.2-T4): the UI badge comes from the
+/// `DomainEvent::AgentRateLimited` bus, not the chat stream, so it maps to `None`
+/// too. Every content-bearing event still maps to exactly one chunk.
 #[must_use]
 pub fn chunk_from_event(event: ReplyEvent) -> Option<ReplyChunk> {
     match event {
@@ -187,5 +189,6 @@ pub fn chunk_from_event(event: ReplyEvent) -> Option<ReplyChunk> {
         ReplyEvent::ToolActivity { label } => Some(ReplyChunk::ToolActivity { label }),
         ReplyEvent::Final { content } => Some(ReplyChunk::Final { content }),
         ReplyEvent::Heartbeat => None,
+        ReplyEvent::RateLimited { .. } => None,
     }
 }

crates/app-tauri/src/commands.rs

@@ -9,17 +9,20 @@ use tauri::State;
 
 use crate::dto::DismissEmbedderSuggestionRequestDto;
 use application::{
-    AppError, AssignSkillToAgentInput, ChangeAgentProfileInput, CloseProjectInput,
-    CreateAgentInput, CreateLayoutInput, CreateMemoryInput, CreateSkillInput, DeleteAgentInput,
-    DeleteEmbedderProfileInput, DeleteLayoutInput, DeleteMemoryInput, DeleteSkillInput,
-    DeleteTemplateInput, DetectAgentDriftInput, GetMemoryInput, GitBranchesInput, GitCheckoutInput,
-    GitCommitInput, GitGraphInput, GitInitInput, GitLogInput, GitStagePathInput, GitStatusInput,
-    InspectConversationInput, LaunchAgentInput, ListAgentsInput, ListLayoutsInput,
-    ListMemoriesInput, ListResumableAgentsInput, ListSkillsInput, LiveSessions, LoadLayoutInput,
-    McpRuntime, MutateLayoutInput, OpenProjectInput, ReadAgentContextInput, ReadMemoryIndexInput,
-    ReadProjectContextInput, RecallMemoryInput, ReconcileLayoutsInput, RenameLayoutInput,
-    ResolveAgentPermissionsInput, ResolveMemoryLinksInput, SetActiveLayoutInput,
-    SnapshotRunningAgentsInput, SyncAgentWithTemplateInput, UnassignSkillFromAgentInput,
+    AppError, AssignSkillToAgentInput, AttachLiveAgentInput, ChangeAgentProfileInput,
+    CloseProjectInput, CreateAgentInput, CreateLayoutInput, CreateMemoryInput, CreateSkillInput,
+    DeleteAgentInput, DeleteEmbedderProfileInput, DeleteLayoutInput, DeleteMemoryInput,
+    DeleteSkillInput, DeleteTemplateInput, DetectAgentDriftInput, GetMemoryInput,
+    GetProjectWorkStateInput, GitBranchesInput, GitCheckoutInput, GitCommitInput, GitGraphInput,
+    GitInitInput, GitLogInput, GitStagePathInput, GitStatusInput, InspectConversationInput,
+    LaunchAgentInput, ListAgentsInput, ListLayoutsInput, ListMemoriesInput,
+    ListResumableAgentsInput, ListSkillsInput, LiveSessions, LoadLayoutInput, McpRuntime,
+    MutateLayoutInput, OpenProjectInput, ReadAgentContextInput, ReadConversationPageInput,
+    ReadMemoryIndexInput, ReadProjectContextInput, RecallMemoryInput, ReconcileLayoutsInput,
+    ReconcileLiveStateInput,
+    RenameLayoutInput, ResolveAgentPermissionsInput, ResolveMemoryLinksInput,
+    RotateConversationLogInput, SetActiveLayoutInput, SnapshotRunningAgentsInput,
+    StopLiveAgentInput, SyncAgentWithTemplateInput, UnassignSkillFromAgentInput,
     UpdateAgentContextInput, UpdateAgentPermissionsInput, UpdateMemoryInput,
     UpdateProjectContextInput, UpdateProjectPermissionsInput, UpdateSkillInput,
 };
@@ -29,26 +32,27 @@ use crate::dto::{
     parse_agent_id, parse_close_terminal, parse_delete_profile, parse_layout_id, parse_memory_slug,
     parse_node_id, parse_profile_id, parse_project_id, parse_session_id, parse_skill_id,
     parse_template_id, parse_ticket_id, AgentDriftListDto, AgentDto, AgentListDto,
-    AssignSkillRequestDto, AttachLiveAgentRequestDto, ChangeAgentProfileDto,
-    ChangeAgentProfileRequestDto, ConfigureProfilesRequestDto, ConversationDetailsDto,
-    CreateAgentFromTemplateRequestDto, CreateAgentRequestDto, CreateLayoutRequestDto,
-    CreateLayoutResultDto, CreateMemoryRequestDto, CreateProjectRequestDto, CreateSkillRequestDto,
-    CreateTemplateRequestDto, DeleteLayoutRequestDto, DeleteLayoutResultDto,
+    AssignSkillRequestDto, AttachLiveAgentRequestDto, AttachLiveAgentResponseDto,
+    ChangeAgentProfileDto, ChangeAgentProfileRequestDto, ConfigureProfilesRequestDto,
+    ConversationDetailsDto, CreateAgentFromTemplateRequestDto, CreateAgentRequestDto,
+    CreateLayoutRequestDto, CreateLayoutResultDto, CreateMemoryRequestDto, CreateProjectRequestDto,
+    CreateSkillRequestDto, CreateTemplateRequestDto, DeleteLayoutRequestDto, DeleteLayoutResultDto,
     DeliveredDelegationRequestDto, DetectProfilesRequestDto, DetectProfilesResponseDto,
     EffectivePermissionsDto, EmbedderEnginesDto, EmbedderProfileDto, EmbedderProfileListDto,
     ErrorDto, FirstRunStateDto, FrontAttachedRequestDto, GitBranchesDto, GitCheckoutRequestDto,
-    GitCommitDto,
-    GitCommitListDto, GitCommitRequestDto, GitStageRequestDto, GitStatusListDto,
+    GitCommitDto, GitCommitListDto, GitCommitRequestDto, GitStageRequestDto, GitStatusListDto,
     GraphCommitListDto, HealthRequestDto, HealthResponseDto, InspectConversationRequestDto,
     InterruptAgentRequestDto, LaunchAgentRequestDto, LayoutDto, LayoutOperationDto, ListLayoutsDto,
     LiveAgentListDto, MemoryDto, MemoryIndexDto, MemoryLinksDto, MemoryListDto,
     OpenTerminalRequestDto, ProfileDto, ProfileListDto, ProjectDto, ProjectListDto,
-    ProjectPermissionsDto, ReadAgentContextResponseDto, ReattachChatDto, ReattachResultDto,
-    RecallMemoryRequestDto, RenameLayoutRequestDto, ReplyChunk, ResizeTerminalRequestDto,
+    ProjectPermissionsDto, ProjectWorkStateDto, ReadAgentContextResponseDto,
+    ReadConversationPageRequestDto, ReattachChatDto, ReattachResultDto, RecallMemoryRequestDto,
+    RenameLayoutRequestDto, ReplyChunk, ResizeTerminalRequestDto,
     ResolveAgentPermissionsRequestDto, ResumableAgentListDto, SaveEmbedderProfileRequestDto,
     SaveProfileRequestDto, SetActiveLayoutRequestDto, SkillDto, SkillListDto,
-    SyncAgentWithTemplateRequestDto, SyncResultDto, TemplateDto, TemplateListDto,
-    TerminalClosedDto, TerminalSessionDto, UnassignSkillRequestDto, UpdateAgentContextRequestDto,
+    StopLiveAgentRequestDto, StopLiveAgentResponseDto, SyncAgentWithTemplateRequestDto,
+    SyncResultDto, TemplateDto, TemplateListDto, TerminalClosedDto, TerminalSessionDto,
+    TurnPageDto, UnassignSkillRequestDto, UpdateAgentContextRequestDto,
     UpdateAgentPermissionsRequestDto, UpdateMemoryRequestDto, UpdateProjectContextRequestDto,
     UpdateProjectPermissionsRequestDto, UpdateSkillRequestDto, UpdateTemplateRequestDto,
     WriteTerminalRequestDto,
@@ -121,6 +125,16 @@ pub async fn open_project(
         .reconcile_layouts
         .execute(ReconcileLayoutsInput { project_id: id })
         .await;
+    // Réconcilie les lignes de live-state fantômes : un crash ne déclenche jamais
+    // `close_project`, donc l'ouverture est le seul filet fiable pour repasser en
+    // `idle` les agents `working`/`waiting`/`blocked` dont la session est morte.
+    // Acte système (appelle le port live-state directement, jamais via la surface
+    // MCP self-only). Best-effort : un échec ne bloque pas l'ouverture. Tourne
+    // AVANT toute relance d'agent (toute reprise réécrit ensuite en LWW).
+    let _ = state
+        .reconcile_live_state
+        .execute(ReconcileLiveStateInput { project_id: id })
+        .await;
     // (Re)start the orchestrator watcher for this project (idempotent, §14.3).
     state.ensure_orchestrator_watch(&output.project);
     state.reconcile_claude_run_dirs(&output.project).await;
@@ -365,7 +379,46 @@ pub fn write_terminal(
     state: State<'_, AppState>,
 ) -> Result<(), ErrorDto> {
     let input = request.into_input()?;
-    state.write_terminal.execute(input).map_err(ErrorDto::from)
+    let session_id = input.session_id;
+    let bytes = input.data.len();
+    let control = describe_terminal_write(&input.data);
+    application::diag!(
+        "[pty-write] write_terminal start: session={session_id} bytes={bytes} control={control}"
+    );
+    match state.write_terminal.execute(input) {
+        Ok(()) => {
+            application::diag!(
+                "[pty-write] write_terminal ok: session={session_id} bytes={bytes} control={control}"
+            );
+            Ok(())
+        }
+        Err(e) => {
+            application::diag!(
+                "[pty-write] write_terminal failed: session={session_id} bytes={bytes} \
+                 control={control} error={e}"
+            );
+            Err(ErrorDto::from(e))
+        }
+    }
+}
+
+fn describe_terminal_write(data: &[u8]) -> String {
+    if data.is_empty() {
+        return "<empty>".to_owned();
+    }
+    if data.len() > 16 {
+        return "<bulk>".to_owned();
+    }
+    data.iter()
+        .map(|byte| match *byte {
+            b'\r' => "\\r".to_owned(),
+            b'\n' => "\\n".to_owned(),
+            0x7f => "\\x7f".to_owned(),
+            byte if byte < 0x20 => format!("\\x{byte:02x}"),
+            byte => char::from(byte).to_string(),
+        })
+        .collect::<Vec<_>>()
+        .join("")
 }
 
 /// `resize_terminal` — resize a live PTY.
@@ -930,6 +983,58 @@ pub async fn list_agents(
         .map_err(ErrorDto::from)
 }
 
+/// `get_project_work_state` — read-only live/busy state for manifest agents.
+///
+/// # Errors
+/// Returns an [`ErrorDto`] (`INVALID` for a malformed id, `NOT_FOUND` if the
+/// project is unknown, `STORE` on manifest I/O failure).
+#[tauri::command]
+pub async fn get_project_work_state(
+    project_id: String,
+    state: State<'_, AppState>,
+) -> Result<ProjectWorkStateDto, ErrorDto> {
+    let project = resolve_project(&project_id, &state).await?;
+    state
+        .get_project_work_state
+        .execute(GetProjectWorkStateInput { project })
+        .await
+        .map(ProjectWorkStateDto::from)
+        .map_err(ErrorDto::from)
+}
+
+/// `read_conversation_page` — human, paginated read of a conversation's **full**
+/// transcript (lot LS6). Archive-aware (segments + active), text never truncated.
+///
+/// # Errors
+/// Returns an [`ErrorDto`] (`INVALID` for a malformed project/conversation id,
+/// `NOT_FOUND` if the project is unknown, `STORE` on log I/O failure).
+#[tauri::command]
+pub async fn read_conversation_page(
+    request: ReadConversationPageRequestDto,
+    state: State<'_, AppState>,
+) -> Result<TurnPageDto, ErrorDto> {
+    let project = resolve_project(&request.project_id, &state).await?;
+    let conversation = uuid::Uuid::parse_str(&request.conversation_id)
+        .map(domain::ConversationId::from_uuid)
+        .map_err(|_| ErrorDto {
+            code: "INVALID".to_owned(),
+            message: format!("invalid conversation id: {}", request.conversation_id),
+        })?;
+    let cursor = request.cursor();
+    let limit = request.limit.unwrap_or(0);
+    state
+        .read_conversation_page
+        .execute(ReadConversationPageInput {
+            project_root: project.root,
+            conversation,
+            cursor,
+            limit,
+        })
+        .await
+        .map(TurnPageDto::from)
+        .map_err(ErrorDto::from)
+}
+
 /// `list_live_agents` — list every agent that currently owns a live session
 /// (raw PTY **or** structured/chat) and the cell hosting each, so the UI can
 /// disable an agent already running in another cell (the "one live session per
@@ -979,20 +1084,45 @@ pub fn list_live_agents(
 pub async fn attach_live_agent(
     request: AttachLiveAgentRequestDto,
     state: State<'_, AppState>,
-) -> Result<LiveAgentListDto, ErrorDto> {
-    let _project = resolve_project(&request.project_id, &state).await?;
+) -> Result<AttachLiveAgentResponseDto, ErrorDto> {
+    let project = resolve_project(&request.project_id, &state).await?;
     let agent_id = parse_agent_id(&request.agent_id)?;
     let node_id = parse_node_id(&request.node_id)?;
-    let session = state
-        .terminal_sessions
-        .rebind_agent_node(&agent_id, node_id)
-        .ok_or_else(|| AppError::NotFound(format!("running session for agent {agent_id}")))?;
+    state
+        .attach_live_agent
+        .execute(AttachLiveAgentInput {
+            project,
+            agent_id,
+            node_id,
+        })
+        .map(AttachLiveAgentResponseDto::from)
+        .map_err(ErrorDto::from)
+}
 
-    Ok(LiveAgentListDto::from_pairs(vec![(
-        agent_id,
-        session.node_id,
-        session.id,
-    )]))
+/// `stop_live_agent` — tear down an already-running agent's live session by agent
+/// id, polymorphically (PTY kill or structured shutdown), without removing the
+/// agent, its tickets, conversation summary or handoff.
+///
+/// # Errors
+/// Returns an [`ErrorDto`] (`INVALID` for malformed ids, `NOT_FOUND` if the
+/// project/agent is unknown or the agent has no live session, `PROCESS` on a
+/// kill/shutdown failure).
+#[tauri::command]
+pub async fn stop_live_agent(
+    request: StopLiveAgentRequestDto,
+    state: State<'_, AppState>,
+) -> Result<StopLiveAgentResponseDto, ErrorDto> {
+    let project = resolve_project(&request.project_id, &state).await?;
+    let agent_id = parse_agent_id(&request.agent_id)?;
+    // Backstop no-reply : arrêter l'observateur de fin de tour de l'agent (le handle est
+    // droppé ⇒ polling stoppé) avant de démonter sa session.
+    state.stop_turn_watch(agent_id);
+    state
+        .stop_live_agent
+        .execute(StopLiveAgentInput { project, agent_id })
+        .await
+        .map(StopLiveAgentResponseDto::from)
+        .map_err(ErrorDto::from)
 }
 
 /// `read_agent_context` — read an agent's Markdown context.
@@ -1137,6 +1267,17 @@ pub async fn launch_agent(
     // artefacts from previous AppImages do not survive into this activation.
     state.reconcile_claude_run_dirs(&project).await;
 
+    // Session-limit resume context (LS7, §21.5): record the Project + cell size keyed by
+    // agent so an auto-resume (which only carries agent/node/conversation) can recompose a
+    // full `LaunchAgentInput`. Cloned here — `project` is moved into the launch below.
+    let resume_project = project.clone();
+    // Lot LS6 — project root captured before `project` moves, for the off-hot-path log
+    // rotation triggered at thread (re)open below.
+    let rotation_root = project.root.clone();
+    // Backstop no-reply — project root captured before `project` moves, to arm the
+    // end-of-turn transcript watcher for the launched agent (cf. `AppState::arm_turn_watch`).
+    let watch_root = project.root.clone();
+
     let output = state
         .launch_agent
         .execute(LaunchAgentInput {
@@ -1153,7 +1294,56 @@ pub async fn launch_agent(
         .await
         .map_err(ErrorDto::from)?;
 
+    if let Ok(mut contexts) = state.resume_contexts.lock() {
+        contexts.insert(
+            agent_id,
+            crate::state::ResumeContext {
+                project: resume_project,
+                rows: request.rows,
+                cols: request.cols,
+            },
+        );
+    }
+
+    // Backstop no-reply : armer l'observateur de fin de tour transcript pour la cible si
+    // son profil est supporté (Claude). Idempotent par remplacement à chaque (re)lancement
+    // effectif (profil résolu présent) ; no-op sur reattach (profil `None`) — le handle
+    // posé au 1er lancement persiste. cwd = run dir isolé de l'agent.
+    if let Some(profile) = output.profile.as_ref() {
+        state.arm_turn_watch(
+            &watch_root,
+            agent_id,
+            profile,
+            output.assigned_conversation_id.clone(),
+        );
+    }
+
+    // Lot LS6 — rotation **best-effort** du log, déclenchée à la (re)ouverture du fil et
+    // **hors chemin chaud** : détachée (`tokio::spawn`) pour n'ajouter aucune latence au
+    // launch, erreurs **avalées** (la rotation ne doit jamais casser une reprise). Un
+    // `append` ne déclenche JAMAIS la rotation. Skippée si la cellule ne porte pas une
+    // `conversation_id` UUID (rien à roter).
+    if let Some(conversation) = request
+        .conversation_id
+        .as_deref()
+        .and_then(|raw| uuid::Uuid::parse_str(raw).ok())
+        .map(domain::ConversationId::from_uuid)
+    {
+        let rotate = std::sync::Arc::clone(&state.rotate_conversation_log);
+        tokio::spawn(async move {
+            let _ = rotate
+                .execute(RotateConversationLogInput {
+                    project_root: rotation_root,
+                    conversation,
+                })
+                .await;
+        });
+    }
+
     let session_id = output.session.id;
+    // Host cell of the freshly (re)launched session — the pivot the level-2 tap reports
+    // to the service alongside the agent.
+    let host_node_id = output.session.node_id;
 
     // §17.4/§17.6: a structured launch routes to an `AgentSession`, registered
     // **only** in `StructuredSessions` — its id is never a live PTY. Such a cell is
@@ -1166,6 +1356,18 @@ pub async fn launch_agent(
         // Register the xterm output channel for this session.
         let gen = state.pty_bridge.register(session_id, on_output);
 
+        // Level-2 session-limit detector (§21, niveau 2 — PTY/TUI sans adapter
+        // structuré). Selection rule (§21.10-4) is the single infra source `applies`:
+        // arm a parser **only** for a profile without a structured adapter that declares
+        // a `rate_limit_pattern` (anti-double-détection avec le niveau 1). A `None`
+        // profile (reattach/idempotent) or an invalid regex ⇒ no parser, jamais de panique.
+        let rate_limit_parser = output
+            .profile
+            .as_ref()
+            .filter(|p| infrastructure::ratelimit::applies(p))
+            .and_then(|p| p.rate_limit_pattern.as_ref())
+            .and_then(infrastructure::RateLimitParser::new);
+
         // Subscribe to the PTY's byte stream and pump it to the channel.
         // The stream is a blocking iterator; it runs on a dedicated OS thread and
         // ends when the PTY hits EOF or this attach is superseded.
@@ -1173,8 +1375,30 @@ pub async fn launch_agent(
         match state.pty_port.subscribe_output(&handle) {
             Ok(stream) => {
                 let bridge: std::sync::Arc<PtyBridge> = std::sync::Arc::clone(&state.pty_bridge);
+                // Captured for the level-2 tap (moved into the pump thread).
+                let service = std::sync::Arc::clone(&state.session_limit_service);
+                let detect_clock = std::sync::Arc::new(infrastructure::SystemClock::new());
+                let conversation_id = request.conversation_id.clone();
                 std::thread::spawn(move || {
                     for chunk in stream {
+                        // §21.10-4 tap (best-effort par fragment) : avant de consommer le
+                        // fragment, on cherche le motif de limite. Une détection arme la
+                        // reprise via le service (détecter→planifier). Dormant si pas de
+                        // parser. La fragmentation PTV (motif coupé entre deux fragments)
+                        // est un raté best-effort connu pour LS7.
+                        if let Some(parser) = &rate_limit_parser {
+                            let text = String::from_utf8_lossy(&chunk);
+                            if let Some(limit) = parser
+                                .detect(&text, domain::ports::Clock::now_millis(&*detect_clock))
+                            {
+                                service.on_rate_limited(
+                                    agent_id,
+                                    host_node_id,
+                                    conversation_id.clone(),
+                                    limit.resets_at_ms,
+                                );
+                            }
+                        }
                         if !bridge.send_output(&session_id, chunk) {
                             break;
                         }
@@ -1279,8 +1503,23 @@ pub async fn agent_send(
     // `Final` event (or stream end / superseded channel), then detaches *only its
     // own* generation so a concurrent re-attach is never torn down.
     let bridge = std::sync::Arc::clone(&state.chat_bridge);
+    // Level-1 session-limit tap (§21, niveau 1 — structuré). Resolve the agent + host
+    // cell of this session once; a `RateLimited` turn event then feeds the service
+    // (détecter→planifier). DORMANT en composition B-2 (aucune session structurée
+    // vivante) mais câblé pour forward-compat. `conversation_id` non disponible ici ⇒
+    // `None` (acceptable LS7).
+    let service = std::sync::Arc::clone(&state.session_limit_service);
+    let meta = state.structured_sessions.meta_for_session(&sid);
     std::thread::spawn(move || {
         for event in stream {
+            // Non-terminal, sans contenu chat : un signal de limite alimente le service
+            // (le badge UI vient du bus `AgentRateLimited`, pas du flux chat) puis on
+            // continue à drainer comme pour un battement.
+            if let domain::ports::ReplyEvent::RateLimited { resets_at_ms } = &event {
+                if let Some((agent_id, node_id)) = meta {
+                    service.on_rate_limited(agent_id, node_id, None, *resets_at_ms);
+                }
+            }
             // Heartbeats carry no chat content (readiness/heartbeat lot 1) ⇒ no wire
             // chunk; skip them while still draining so the turn runs to its `Final`.
             let Some(chunk) = crate::chat::chunk_from_event(event) else {
@@ -1298,6 +1537,76 @@ pub async fn agent_send(
     Ok(())
 }
 
+/// `cancel_resume` — annule la **reprise automatique** armée pour un agent limité
+/// (ARCHITECTURE §21.1-4, fenêtre annulable).
+///
+/// Délègue à [`SessionLimitService::cancel_resume`](application::SessionLimitService::cancel_resume) :
+/// désarme le réveil et, **seulement si** l'annulation a réussi (le réveil n'avait pas
+/// encore tiré), publie `AgentResumeCancelled`. Renvoie `true` ssi une reprise a
+/// effectivement été annulée (`false` si aucune n'était armée, ou si elle venait de
+/// tirer — auquel cas la reprise suit son cours).
+///
+/// # Errors
+/// Returns an [`ErrorDto`] (`INVALID` for a malformed agent id).
+#[tauri::command]
+pub async fn cancel_resume(agent_id: String, state: State<'_, AppState>) -> Result<bool, ErrorDto> {
+    let id = parse_agent_id(&agent_id)?;
+    Ok(state.session_limit_service.cancel_resume(id))
+}
+
+/// `set_resume_at` — **filet humain niveau 3** (ARCHITECTURE §21.1) : l'utilisateur a
+/// saisi l'heure de reset d'un agent en limite **suspectée** (rien n'a matché
+/// automatiquement). Arme la **même** reprise annulable que les niveaux 1/2.
+///
+/// Le front ne dispose que de l'`agent_id` ; on résout côté backend :
+/// - `node_id` : la cellule vivante hébergeant l'agent, cherchée dans la registry
+///   structurée puis dans la registry terminal ([`StructuredSessions::node_for_agent`]
+///   / [`TerminalSessions::node_for_agent`]). Sans cellule vivante, la saisie n'a pas de
+///   cible ⇒ `NOT_FOUND`.
+/// - `conversation_id` : best-effort via la session structurée de l'agent
+///   ([`AgentSession::conversation_id`]) ; `None` toléré (reprise en mode dégradé).
+///
+/// Délègue ensuite à
+/// [`SessionLimitService::confirm_human_resume`](application::SessionLimitService::confirm_human_resume),
+/// qui réémet la paire `AgentRateLimited{Some}` + `AgentResumeScheduled` déjà relayée au
+/// front. Aucun nouvel événement.
+///
+/// # Errors
+/// Returns an [`ErrorDto`] (`INVALID` for a malformed agent id, `NOT_FOUND` if no live
+/// cell hosts the agent).
+#[tauri::command]
+pub async fn set_resume_at(
+    agent_id: String,
+    resets_at_ms: i64,
+    state: State<'_, AppState>,
+) -> Result<(), ErrorDto> {
+    let id = parse_agent_id(&agent_id)?;
+
+    // Résolution agent→cellule : la registry des sessions vivantes est la source de
+    // vérité. On regarde d'abord le structuré (qui porte aussi le `conversation_id`),
+    // puis le terminal (PTY).
+    let node_id = state
+        .structured_sessions
+        .node_for_agent(&id)
+        .or_else(|| state.terminal_sessions.node_for_agent(&id))
+        .ok_or_else(|| {
+            ErrorDto::from(AppError::NotFound(format!(
+                "aucune cellule vivante pour l'agent {id}"
+            )))
+        })?;
+
+    // `conversation_id` best-effort : seule une session structurée vivante l'expose.
+    let conversation_id = state
+        .structured_sessions
+        .session_for_agent(&id)
+        .and_then(|s| s.conversation_id());
+
+    state
+        .session_limit_service
+        .confirm_human_resume(id, node_id, conversation_id, resets_at_ms);
+    Ok(())
+}
+
 /// `interrupt_agent` — the **Interrompre** path (cadrage C4 §4.2).
 ///
 /// Routes to [`OrchestratorService::interrupt_agent`], which `preempt`s the agent's
@@ -1342,6 +1651,10 @@ pub async fn delegation_delivered(
     let project = resolve_project(&request.project_id, &state).await?;
     let agent_id = parse_agent_id(&request.agent_id)?;
     let ticket = parse_ticket_id(&request.ticket)?;
+    application::diag!(
+        "[delivery] delegation_delivered command: project={} agent={agent_id} ticket={ticket}",
+        project.id
+    );
     state
         .orchestrator_service
         .note_delegation_delivered(&project, agent_id, ticket);
@@ -1365,6 +1678,10 @@ pub async fn set_front_attached(
     state: State<'_, AppState>,
 ) -> Result<(), ErrorDto> {
     let agent_id = parse_agent_id(&request.agent_id)?;
+    application::diag!(
+        "[delivery] set_front_attached command: agent={agent_id} attached={}",
+        request.attached
+    );
     state
         .orchestrator_service
         .set_agent_front_attached(agent_id, request.attached);
@@ -1891,6 +2208,10 @@ pub async fn create_skill(
         .create_skill
         .execute(CreateSkillInput {
             name: request.name,
+            // Description is set via the dedicated frontend field (T6); the create
+            // path stays None for now so the affordance falls back to the body's
+            // first line (see `Skill::effective_description`).
+            description: None,
             content: request.content,
             scope: request.scope,
             project_root: project.root,

crates/app-tauri/src/dto.rs

@@ -9,10 +9,13 @@
 use serde::{Deserialize, Serialize};
 
 use application::{
-    AppError, CreateProjectInput, CreateProjectOutput, GitGraphOutput, HealthInput, HealthReport,
-    LayoutKind, ListProjectsOutput, OpenProjectOutput,
+    AgentTicketState, AppError, AttachLiveAgentOutput, ConversationPreviewStatus,
+    ConversationTurnWorkPreview, ConversationWorkSummary, CreateProjectInput, CreateProjectOutput,
+    GitGraphOutput, HealthInput, HealthReport, LayoutKind, ListProjectsOutput, LiveSessionKind,
+    OpenProjectOutput, ProjectWorkState, StopLiveAgentOutput, TicketWorkSource, TicketWorkStatus,
+    TurnPage, TurnSource, TurnView,
 };
-use domain::{Project, ProjectId};
+use domain::{AgentBusyState, PageCursor, PageDirection, Project, ProjectId, TurnRole};
 
 /// Request DTO for the `health` command.
 #[derive(Debug, Clone, Default, Deserialize)]
@@ -1472,6 +1475,270 @@ impl LiveAgentListDto {
     }
 }
 
+/// Runtime family of a live work-state session.
+#[derive(Debug, Clone, Copy, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum LiveWorkSessionKindDto {
+    /// Raw PTY-backed CLI session.
+    Pty,
+    /// Structured agent-session backend.
+    Structured,
+}
+
+impl From<LiveSessionKind> for LiveWorkSessionKindDto {
+    fn from(kind: LiveSessionKind) -> Self {
+        match kind {
+            LiveSessionKind::Pty => Self::Pty,
+            LiveSessionKind::Structured => Self::Structured,
+        }
+    }
+}
+
+/// Live session coordinates in the project work-state read model.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LiveWorkSessionDto {
+    /// The layout node currently hosting the session view.
+    pub node_id: String,
+    /// The live session id.
+    pub session_id: String,
+    /// Runtime family that owns the session.
+    pub kind: LiveWorkSessionKindDto,
+}
+
+/// Derived processing status of a queued ticket.
+#[derive(Debug, Clone, Copy, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TicketWorkStatusDto {
+    /// The agent's current busy turn is running this ticket.
+    InProgress,
+    /// Waiting behind the head / the agent is idle.
+    Queued,
+}
+
+impl From<TicketWorkStatus> for TicketWorkStatusDto {
+    fn from(status: TicketWorkStatus) -> Self {
+        match status {
+            TicketWorkStatus::InProgress => Self::InProgress,
+            TicketWorkStatus::Queued => Self::Queued,
+        }
+    }
+}
+
+/// Origin of a queued ticket (human operator or a delegating agent).
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase", tag = "kind")]
+pub enum TicketWorkSourceDto {
+    /// The human operator.
+    Human,
+    /// Another agent delegating via `idea_ask_agent`.
+    #[serde(rename_all = "camelCase")]
+    Agent {
+        /// The delegating agent id.
+        agent_id: String,
+    },
+}
+
+impl From<TicketWorkSource> for TicketWorkSourceDto {
+    fn from(source: TicketWorkSource) -> Self {
+        match source {
+            TicketWorkSource::Human => Self::Human,
+            TicketWorkSource::Agent { agent_id } => Self::Agent {
+                agent_id: agent_id.to_string(),
+            },
+        }
+    }
+}
+
+/// One queued/in-progress delegation ticket for an agent.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentTicketStateDto {
+    /// Stable id of the queued ticket.
+    pub ticket_id: String,
+    /// Conversation thread this task enters.
+    pub conversation_id: String,
+    /// FIFO position at snapshot time (`0` = head).
+    pub position: u32,
+    /// Derived status (in-progress vs queued).
+    pub status: TicketWorkStatusDto,
+    /// Origin of the ticket.
+    pub source: TicketWorkSourceDto,
+    /// Display label of the requester.
+    pub requester_label: String,
+    /// Bounded excerpt of the task.
+    pub task_preview: String,
+    /// Character length of the original (un-truncated) task.
+    pub task_len: usize,
+}
+
+impl From<AgentTicketState> for AgentTicketStateDto {
+    fn from(ticket: AgentTicketState) -> Self {
+        Self {
+            ticket_id: ticket.ticket_id.to_string(),
+            conversation_id: ticket.conversation_id.to_string(),
+            position: ticket.position,
+            status: ticket.status.into(),
+            source: ticket.source.into(),
+            requester_label: ticket.requester_label,
+            task_preview: ticket.task_preview,
+            task_len: ticket.task_len,
+        }
+    }
+}
+
+/// One manifest agent's current live/busy state.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentWorkStateDto {
+    /// Agent id.
+    pub agent_id: String,
+    /// Agent display name.
+    pub name: String,
+    /// Runtime profile id assigned to the agent.
+    pub profile_id: String,
+    /// Live session, if any.
+    pub live: Option<LiveWorkSessionDto>,
+    /// Current mediated-input busy state.
+    pub busy: AgentBusyState,
+    /// Pending/in-progress delegation tickets, in FIFO order.
+    pub tickets: Vec<AgentTicketStateDto>,
+}
+
+/// How much of a [`ConversationWorkSummaryDto`] could be derived, best-effort.
+#[derive(Debug, Clone, Copy, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum ConversationPreviewStatusDto {
+    /// A handoff was present and usable.
+    Ready,
+    /// No handoff yet; `recentTurns` may carry the log fallback.
+    Missing,
+    /// The handoff was unreadable but the log fallback was readable.
+    Partial,
+    /// Neither the handoff nor the log could be read.
+    Unavailable,
+}
+
+impl From<ConversationPreviewStatus> for ConversationPreviewStatusDto {
+    fn from(status: ConversationPreviewStatus) -> Self {
+        match status {
+            ConversationPreviewStatus::Ready => Self::Ready,
+            ConversationPreviewStatus::Missing => Self::Missing,
+            ConversationPreviewStatus::Partial => Self::Partial,
+            ConversationPreviewStatus::Unavailable => Self::Unavailable,
+        }
+    }
+}
+
+/// One recent turn surfaced in a conversation summary's log fallback.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ConversationTurnWorkPreviewDto {
+    /// Nature of the turn (`prompt`/`response`/`toolActivity`).
+    pub role: TurnRole,
+    /// Origin of the turn (human operator or a delegating agent).
+    pub source: TicketWorkSourceDto,
+    /// Timestamp (epoch milliseconds) of the turn.
+    pub at_ms: u64,
+    /// Bounded excerpt of the turn text.
+    pub text_preview: String,
+    /// Character length of the original (un-truncated) turn text.
+    pub text_len: usize,
+}
+
+impl From<ConversationTurnWorkPreview> for ConversationTurnWorkPreviewDto {
+    fn from(turn: ConversationTurnWorkPreview) -> Self {
+        Self {
+            role: turn.role,
+            source: turn.source.into(),
+            at_ms: turn.at_ms,
+            text_preview: turn.text_preview,
+            text_len: turn.text_len,
+        }
+    }
+}
+
+/// Best-effort, read-only summary of one conversation visible through the tickets.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ConversationWorkSummaryDto {
+    /// The conversation (pair) this summary describes.
+    pub conversation_id: String,
+    /// How much could be derived.
+    pub status: ConversationPreviewStatusDto,
+    /// Bounded excerpt of the handoff objective, when present.
+    pub objective_preview: Option<String>,
+    /// Bounded excerpt of the handoff summary, when present.
+    pub summary_preview: Option<String>,
+    /// Character length of the original (un-truncated) handoff summary (`0` when none).
+    pub summary_len: usize,
+    /// Cursor (last turn id) covered by the handoff summary, when present.
+    pub up_to: Option<String>,
+    /// Bounded, recent turns from the log fallback.
+    pub recent_turns: Vec<ConversationTurnWorkPreviewDto>,
+}
+
+impl From<ConversationWorkSummary> for ConversationWorkSummaryDto {
+    fn from(summary: ConversationWorkSummary) -> Self {
+        Self {
+            conversation_id: summary.conversation_id.to_string(),
+            status: summary.status.into(),
+            objective_preview: summary.objective_preview,
+            summary_preview: summary.summary_preview,
+            summary_len: summary.summary_len,
+            up_to: summary.up_to.map(|cursor| cursor.to_string()),
+            recent_turns: summary
+                .recent_turns
+                .into_iter()
+                .map(ConversationTurnWorkPreviewDto::from)
+                .collect(),
+        }
+    }
+}
+
+/// Project-level read model for conversation/delegation UX.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProjectWorkStateDto {
+    /// Manifest agents in manifest order, enriched with live/busy state.
+    pub agents: Vec<AgentWorkStateDto>,
+    /// Best-effort summaries of the conversations referenced by the tickets,
+    /// joined frontend-side via `tickets[].conversationId`.
+    pub conversations: Vec<ConversationWorkSummaryDto>,
+}
+
+impl From<ProjectWorkState> for ProjectWorkStateDto {
+    fn from(state: ProjectWorkState) -> Self {
+        Self {
+            agents: state
+                .agents
+                .into_iter()
+                .map(|agent| AgentWorkStateDto {
+                    agent_id: agent.agent_id.to_string(),
+                    name: agent.name,
+                    profile_id: agent.profile_id.to_string(),
+                    live: agent.live.map(|live| LiveWorkSessionDto {
+                        node_id: live.node_id.to_string(),
+                        session_id: live.session_id.to_string(),
+                        kind: live.kind.into(),
+                    }),
+                    busy: agent.busy,
+                    tickets: agent
+                        .tickets
+                        .into_iter()
+                        .map(AgentTicketStateDto::from)
+                        .collect(),
+                })
+                .collect(),
+            conversations: state
+                .conversations
+                .into_iter()
+                .map(ConversationWorkSummaryDto::from)
+                .collect(),
+        }
+    }
+}
+
 /// Request DTO for `attach_live_agent`: bind an already-running agent session to
 /// a visible layout cell without spawning a new process.
 #[derive(Debug, Clone, Deserialize)]
@@ -1485,6 +1752,64 @@ pub struct AttachLiveAgentRequestDto {
     pub node_id: String,
 }
 
+/// Response DTO for `attach_live_agent`: the rebound live session's coordinates.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AttachLiveAgentResponseDto {
+    /// The rebound agent's id.
+    pub agent_id: String,
+    /// The node now hosting the session view.
+    pub node_id: String,
+    /// The (unchanged) live session id.
+    pub session_id: String,
+    /// Runtime family that owns the session (`pty`/`structured`).
+    pub kind: LiveWorkSessionKindDto,
+}
+
+impl From<AttachLiveAgentOutput> for AttachLiveAgentResponseDto {
+    fn from(out: AttachLiveAgentOutput) -> Self {
+        Self {
+            agent_id: out.agent_id.to_string(),
+            node_id: out.node_id.to_string(),
+            session_id: out.session_id.to_string(),
+            kind: out.kind.into(),
+        }
+    }
+}
+
+/// Request DTO for `stop_live_agent`: tear down an already-running agent's live
+/// session by agent id (no spawn, agent entity preserved).
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StopLiveAgentRequestDto {
+    /// Id of the owning project (validated for symmetry and future scoping).
+    pub project_id: String,
+    /// Id of the running agent to stop.
+    pub agent_id: String,
+}
+
+/// Response DTO for `stop_live_agent`: the torn-down session's coordinates.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StopLiveAgentResponseDto {
+    /// The stopped agent's id.
+    pub agent_id: String,
+    /// The id of the session that was torn down.
+    pub session_id: String,
+    /// Runtime family that owned the session (`pty`/`structured`).
+    pub kind: LiveWorkSessionKindDto,
+}
+
+impl From<StopLiveAgentOutput> for StopLiveAgentResponseDto {
+    fn from(out: StopLiveAgentOutput) -> Self {
+        Self {
+            agent_id: out.agent_id.to_string(),
+            session_id: out.session_id.to_string(),
+            kind: out.kind.into(),
+        }
+    }
+}
+
 /// Parses an agent-id string (UUID) coming from the frontend.
 ///
 /// # Errors
@@ -2275,3 +2600,249 @@ pub fn parse_memory_slug(raw: &str) -> Result<MemorySlug, ErrorDto> {
         message: format!("invalid memory slug: {raw}"),
     })
 }
+
+// ── Conversation pagination (lot LS6) ────────────────────────────────────────
+
+/// Request DTO for `read_conversation_page` — a human, paginated transcript read.
+///
+/// `anchor` is a turn id to paginate around (omit to start from a thread end);
+/// `direction` is `"forward"` (towards newer) or `"backward"` (towards older,
+/// default — the human view opens on the latest page); `limit` is clamped by the
+/// domain to `[1, 200]` (omit/`0` ⇒ default 50).
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReadConversationPageRequestDto {
+    /// The owning project's id.
+    pub project_id: String,
+    /// The conversation (pair) id to read.
+    pub conversation_id: String,
+    /// Optional anchor turn id; omit to start from a thread end.
+    #[serde(default)]
+    pub anchor: Option<String>,
+    /// Pagination direction (`"forward"` or `"backward"`); defaults to backward.
+    #[serde(default)]
+    pub direction: Option<String>,
+    /// Requested page size (omit/`0` ⇒ default; clamped to `[1, 200]`).
+    #[serde(default)]
+    pub limit: Option<usize>,
+}
+
+impl ReadConversationPageRequestDto {
+    /// Builds the domain [`PageCursor`] from the request (default direction backward,
+    /// an unparseable anchor degrades to `None` = a thread-end page).
+    #[must_use]
+    pub fn cursor(&self) -> PageCursor {
+        let direction = match self.direction.as_deref() {
+            Some(d) if d.eq_ignore_ascii_case("forward") => PageDirection::Forward,
+            _ => PageDirection::Backward,
+        };
+        let anchor = self
+            .anchor
+            .as_deref()
+            .and_then(|raw| uuid::Uuid::parse_str(raw).ok())
+            .map(domain::TurnId::from_uuid);
+        PageCursor { anchor, direction }
+    }
+}
+
+/// Origin of a turn in the human transcript view (mirrors [`TurnSource`]).
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase", tag = "kind")]
+pub enum TurnSourceDto {
+    /// The human operator.
+    Human,
+    /// Another agent (delegation via `idea_ask_agent`).
+    #[serde(rename_all = "camelCase")]
+    Agent {
+        /// The originating agent id.
+        agent_id: String,
+    },
+}
+
+impl From<TurnSource> for TurnSourceDto {
+    fn from(source: TurnSource) -> Self {
+        match source {
+            TurnSource::Human => Self::Human,
+            TurnSource::Agent { agent_id } => Self::Agent {
+                agent_id: agent_id.to_string(),
+            },
+        }
+    }
+}
+
+/// One turn in the human transcript — **full text, never truncated**.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TurnViewDto {
+    /// Stable turn id (also the pagination anchor).
+    pub id: String,
+    /// Timestamp (epoch milliseconds).
+    pub at_ms: u64,
+    /// Turn nature (prompt, response, tool activity).
+    pub role: TurnRole,
+    /// Origin (human or delegating agent).
+    pub source: TurnSourceDto,
+    /// The turn's **complete** text (not truncated).
+    pub text: String,
+    /// Character length of the text.
+    pub text_len: usize,
+}
+
+impl From<TurnView> for TurnViewDto {
+    fn from(turn: TurnView) -> Self {
+        Self {
+            id: turn.id.to_string(),
+            at_ms: turn.at_ms,
+            role: turn.role,
+            source: turn.source.into(),
+            text: turn.text,
+            text_len: turn.text_len,
+        }
+    }
+}
+
+/// A page of the human transcript, oldest-to-newest.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TurnPageDto {
+    /// The page's turns, oldest to newest.
+    pub turns: Vec<TurnViewDto>,
+    /// Whether more turns exist beyond the page in the travel direction.
+    pub has_more: bool,
+    /// Last turn id of the page (anchor for the next request), or `None` if empty.
+    pub next_anchor: Option<String>,
+}
+
+impl From<TurnPage> for TurnPageDto {
+    fn from(page: TurnPage) -> Self {
+        Self {
+            turns: page.turns.into_iter().map(TurnViewDto::from).collect(),
+            has_more: page.has_more,
+            next_anchor: page.next_anchor.map(|id| id.to_string()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod ls6_pagination_tests {
+    //! LS6 — DTO de la lecture humaine paginée : parsing du curseur + mapping riche
+    //! `TurnPage → TurnPageDto` (texte complet non borné, source Human/Agent, `has_more`,
+    //! `next_anchor`). C'est le « round-trip d'une page » testable sans `State` Tauri.
+
+    use super::*;
+    use application::{TurnPage, TurnSource, TurnView};
+
+    fn tid(n: u128) -> domain::TurnId {
+        domain::TurnId::from_uuid(uuid::Uuid::from_u128(n))
+    }
+
+    #[test]
+    fn request_cursor_defaults_to_backward_and_parses_anchor() {
+        // Pas de direction ⇒ backward (la vue humaine ouvre sur la page la plus récente).
+        let req = ReadConversationPageRequestDto {
+            project_id: "p".into(),
+            conversation_id: "c".into(),
+            anchor: None,
+            direction: None,
+            limit: None,
+        };
+        let cur = req.cursor();
+        assert_eq!(cur.direction, PageDirection::Backward);
+        assert_eq!(cur.anchor, None);
+
+        // Forward (insensible à la casse) + ancre UUID valide.
+        let u = uuid::Uuid::from_u128(9);
+        let req = ReadConversationPageRequestDto {
+            project_id: "p".into(),
+            conversation_id: "c".into(),
+            anchor: Some(u.to_string()),
+            direction: Some("Forward".into()),
+            limit: Some(10),
+        };
+        let cur = req.cursor();
+        assert_eq!(cur.direction, PageDirection::Forward);
+        assert_eq!(cur.anchor, Some(domain::TurnId::from_uuid(u)));
+
+        // Ancre non-UUID ⇒ dégrade en None (page depuis un bout du fil), jamais d'erreur.
+        let req = ReadConversationPageRequestDto {
+            project_id: "p".into(),
+            conversation_id: "c".into(),
+            anchor: Some("not-a-uuid".into()),
+            direction: Some("backward".into()),
+            limit: None,
+        };
+        assert_eq!(req.cursor().anchor, None);
+    }
+
+    #[test]
+    fn turn_page_dto_round_trips_full_text_and_maps_sources() {
+        let big = "Z".repeat(40_000);
+        let page = TurnPage {
+            turns: vec![
+                TurnView {
+                    id: tid(1),
+                    at_ms: 1_700_000_000_000,
+                    role: TurnRole::Prompt,
+                    source: TurnSource::Human,
+                    text: big.clone(),
+                    text_len: big.chars().count(),
+                },
+                TurnView {
+                    id: tid(2),
+                    at_ms: 1_700_000_000_001,
+                    role: TurnRole::Response,
+                    source: TurnSource::Agent {
+                        agent_id: domain::AgentId::from_uuid(uuid::Uuid::from_u128(7)),
+                    },
+                    text: "réponse".to_owned(),
+                    text_len: 7,
+                },
+            ],
+            has_more: true,
+            next_anchor: Some(tid(2)),
+        };
+
+        let dto = TurnPageDto::from(page);
+        // Texte complet préservé (non borné) + text_len.
+        assert_eq!(dto.turns[0].text.chars().count(), 40_000);
+        assert_eq!(dto.turns[0].text_len, 40_000);
+        // next_anchor stringifié, has_more porté.
+        assert!(dto.has_more);
+        assert_eq!(
+            dto.next_anchor.as_deref(),
+            Some(tid(2).to_string().as_str())
+        );
+
+        // Round-trip JSON (la « page » telle qu'envoyée au front) : camelCase + source.
+        let json = serde_json::to_value(&dto).unwrap();
+        assert_eq!(json["hasMore"], serde_json::json!(true));
+        assert_eq!(json["nextAnchor"], serde_json::json!(tid(2).to_string()));
+        assert_eq!(
+            json["turns"][0]["source"]["kind"],
+            serde_json::json!("human")
+        );
+        assert_eq!(
+            json["turns"][1]["source"]["kind"],
+            serde_json::json!("agent")
+        );
+        assert_eq!(
+            json["turns"][1]["source"]["agentId"],
+            serde_json::json!(uuid::Uuid::from_u128(7).to_string())
+        );
+        // Le texte intégral survit au passage JSON.
+        assert_eq!(
+            json["turns"][0]["text"].as_str().unwrap().chars().count(),
+            40_000
+        );
+    }
+
+    #[test]
+    fn empty_turn_page_dto_has_no_next_anchor() {
+        let dto = TurnPageDto::from(TurnPage {
+            turns: Vec::new(),
+            has_more: false,
+            next_anchor: None,
+        });
+        assert!(dto.turns.is_empty() && !dto.has_more && dto.next_anchor.is_none());
+    }
+}

crates/app-tauri/src/events.rs

@@ -172,6 +172,16 @@ pub enum DomainEventDto {
         /// badge the source.
         source: OrchestrationSourceDto,
     },
+    /// The project's orchestrator designation changed (T1).
+    #[serde(rename_all = "camelCase")]
+    OrchestratorChanged {
+        /// The project whose designation changed.
+        project_id: String,
+        /// The newly designated orchestrator agent, or `None` for the default
+        /// (the oldest agent orchestrates).
+        #[serde(skip_serializing_if = "Option::is_none")]
+        orchestrator: Option<String>,
+    },
     /// A memory note was created or updated.
     #[serde(rename_all = "camelCase")]
     MemorySaved {
@@ -205,6 +215,52 @@ pub enum DomainEventDto {
         /// Whether the in-process ONNX capability is compiled in.
         vector_onnx_enabled: bool,
     },
+    /// An agent entered a **session/rate limit** (ARCHITECTURE §21). Low-frequency,
+    /// model-agnostic badge: carries only the neutral "limited, maybe resets at T"
+    /// fact. The frontend badges "limité jusqu'à HH:MM".
+    #[serde(rename_all = "camelCase")]
+    AgentRateLimited {
+        /// Agent id (UUID string).
+        agent_id: String,
+        /// Reset instant in **epoch-milliseconds**; `null` ⇒ unknown (no auto-resume).
+        #[serde(skip_serializing_if = "Option::is_none")]
+        resets_at_ms: Option<i64>,
+    },
+    /// An **auto-resume** was armed for a rate-limited agent (ARCHITECTURE §21). The
+    /// frontend shows the countdown + the "Annuler la reprise" button (cancellable
+    /// window).
+    #[serde(rename_all = "camelCase")]
+    AgentResumeScheduled {
+        /// Agent id (UUID string).
+        agent_id: String,
+        /// Wake-up deadline in **epoch-milliseconds**.
+        fire_at_ms: i64,
+    },
+    /// An agent's **auto-resume** was **cancelled** (ARCHITECTURE §21): the user
+    /// clicked "Annuler la reprise". The frontend removes the countdown.
+    #[serde(rename_all = "camelCase")]
+    AgentResumeCancelled {
+        /// Agent id (UUID string).
+        agent_id: String,
+    },
+    /// An agent was effectively **resumed** after a limit (ARCHITECTURE §21): the
+    /// wake-up fired (or immediate resume). The frontend clears the "limited" state.
+    #[serde(rename_all = "camelCase")]
+    AgentResumed {
+        /// Agent id (UUID string).
+        agent_id: String,
+    },
+    /// **Human net (level 3)**: a session limit is **suspected** without any reliable
+    /// reset time (ARCHITECTURE §21.1). IdeA never resumes blind: this asks the front
+    /// to **prompt the user** ("limit detected but time unknown — resume at?").
+    #[serde(rename_all = "camelCase")]
+    AgentRateLimitSuspected {
+        /// Agent id (UUID string).
+        agent_id: String,
+        /// Reset instant in **epoch-milliseconds** if an estimate exists, else `null`.
+        #[serde(skip_serializing_if = "Option::is_none")]
+        resets_at_ms: Option<i64>,
+    },
     /// Raw PTY output (normally routed to a per-session channel, not here).
     #[serde(rename_all = "camelCase")]
     PtyOutput {
@@ -355,6 +411,13 @@ impl From<&DomainEvent> for DomainEventDto {
                 ok: *ok,
                 source: (*source).into(),
             },
+            DomainEvent::OrchestratorChanged {
+                project_id,
+                orchestrator,
+            } => Self::OrchestratorChanged {
+                project_id: project_id.to_string(),
+                orchestrator: orchestrator.as_ref().map(|a| a.to_string()),
+            },
             DomainEvent::MemorySaved { slug } => Self::MemorySaved {
                 slug: slug.as_str().to_string(),
             },
@@ -377,6 +440,33 @@ impl From<&DomainEvent> for DomainEventDto {
                 vector_http_enabled: *vector_http_enabled,
                 vector_onnx_enabled: *vector_onnx_enabled,
             },
+            DomainEvent::AgentRateLimited {
+                agent_id,
+                resets_at_ms,
+            } => Self::AgentRateLimited {
+                agent_id: agent_id.to_string(),
+                resets_at_ms: *resets_at_ms,
+            },
+            DomainEvent::AgentResumeScheduled {
+                agent_id,
+                fire_at_ms,
+            } => Self::AgentResumeScheduled {
+                agent_id: agent_id.to_string(),
+                fire_at_ms: *fire_at_ms,
+            },
+            DomainEvent::AgentResumeCancelled { agent_id } => Self::AgentResumeCancelled {
+                agent_id: agent_id.to_string(),
+            },
+            DomainEvent::AgentResumed { agent_id } => Self::AgentResumed {
+                agent_id: agent_id.to_string(),
+            },
+            DomainEvent::AgentRateLimitSuspected {
+                agent_id,
+                resets_at_ms,
+            } => Self::AgentRateLimitSuspected {
+                agent_id: agent_id.to_string(),
+                resets_at_ms: *resets_at_ms,
+            },
             DomainEvent::PtyOutput { session_id, bytes } => Self::PtyOutput {
                 session_id: session_id.to_string(),
                 bytes: bytes.clone(),
@@ -450,4 +540,19 @@ mod tests {
         assert_eq!(json["type"], "agentLivenessChanged");
         assert_eq!(json["liveness"], "alive");
     }
+
+    /// LS6 : un `AgentRateLimited` du domaine se relaie en DTO portant le même agent
+    /// et l'heure de reset (époche-ms), et se sérialise en `"agentRateLimited"` avec
+    /// `resetsAtMs` — le fait neutre que le front badge « limité jusqu'à HH:MM ».
+    #[test]
+    fn rate_limited_relays_to_dto_and_wire() {
+        let dto = DomainEventDto::from(&DomainEvent::AgentRateLimited {
+            agent_id: agent(11),
+            resets_at_ms: Some(1_700_000_000_000),
+        });
+        let json = serde_json::to_value(&dto).expect("serialisable");
+        assert_eq!(json["type"], "agentRateLimited");
+        assert_eq!(json["agentId"], agent(11).to_string());
+        assert_eq!(json["resetsAtMs"], 1_700_000_000_000_i64);
+    }
 }

crates/app-tauri/src/lib.rs

@@ -75,6 +75,12 @@ pub fn run() {
                 .path()
                 .app_data_dir()
                 .expect("failed to resolve the app data directory");
+            // Point the orchestrator's best-effort diagnostics at a persistent file
+            // (`<app-data>/logs/idea.log`) so inter-agent rendezvous beacons survive a
+            // click-launched AppImage (whose stderr is otherwise discarded). Best-effort:
+            // if the file can't be opened the beacons simply stay on stderr.
+            application::diag::set_log_path(app_data_dir.join("logs").join("idea.log"));
+            application::diag!("[startup] IdeA launched; diagnostics log armed");
             let app_state = AppState::build(app_data_dir);
 
             // Wire the domain event bus → Tauri events relay.
@@ -157,14 +163,19 @@ pub fn run() {
             commands::dismiss_embedder_suggestion,
             commands::create_agent,
             commands::list_agents,
+            commands::get_project_work_state,
+            commands::read_conversation_page,
             commands::list_live_agents,
             commands::attach_live_agent,
+            commands::stop_live_agent,
             commands::read_agent_context,
             commands::update_agent_context,
             commands::delete_agent,
             commands::launch_agent,
             commands::change_agent_profile,
             commands::agent_send,
+            commands::cancel_resume,
+            commands::set_resume_at,
             commands::interrupt_agent,
             commands::delegation_delivered,
             commands::set_front_attached,

crates/app-tauri/src/mcp_bridge.rs

@@ -508,8 +508,14 @@ mod tests {
 
         let out = String::from_utf8(cli_out).unwrap();
         // Both request responses arrived; the notification produced none.
-        assert!(out.contains("\"id\":1"), "missing initialize response: {out}");
-        assert!(out.contains("\"id\":2"), "missing tools/list response: {out}");
+        assert!(
+            out.contains("\"id\":1"),
+            "missing initialize response: {out}"
+        );
+        assert!(
+            out.contains("\"id\":2"),
+            "missing tools/list response: {out}"
+        );
     }
 
     /// stdin EOF with no request ⇒ relay returns `Ok` (code 0), having still sent

crates/app-tauri/src/mcp_endpoint.rs

@@ -87,13 +87,29 @@ impl McpEndpoint {
 /// per-user runtime dir (`$XDG_RUNTIME_DIR`, falling back to `$TMPDIR`, then
 /// `/tmp`). Kept short so the full socket path stays well under the ~108-byte
 /// `sockaddr_un` limit (`/run/user/<uid>/idea-mcp/<32 hex>.sock` ≈ 50 bytes).
+///
+/// The candidate bases are tried **in priority order**, returning the first whose
+/// `idea-mcp` subdir exists or can be created. A set-but-unusable `$XDG_RUNTIME_DIR`
+/// (e.g. a sandbox/CI where it points at a non-existent or read-only path) must not
+/// dead-end the loopback bind: without this fallback the socket silently never
+/// binds and inter-agent delegation dies. Deterministic for a given environment, so
+/// the bind side and any `socket_path()` reader always agree on the same directory.
 #[cfg(unix)]
 fn unix_runtime_dir() -> PathBuf {
-    let base = std::env::var_os("XDG_RUNTIME_DIR")
-        .map(PathBuf::from)
-        .or_else(|| std::env::var_os("TMPDIR").map(PathBuf::from))
-        .unwrap_or_else(|| PathBuf::from("/tmp"));
-    base.join("idea-mcp")
+    let candidates = [
+        std::env::var_os("XDG_RUNTIME_DIR").map(PathBuf::from),
+        std::env::var_os("TMPDIR").map(PathBuf::from),
+        Some(PathBuf::from("/tmp")),
+    ];
+    for base in candidates.into_iter().flatten() {
+        let dir = base.join("idea-mcp");
+        if dir.is_dir() || std::fs::create_dir_all(&dir).is_ok() {
+            return dir;
+        }
+    }
+    // Last resort: keep the historical `/tmp` target even if creation just failed
+    // (the bind will surface the real error rather than silently picking nowhere).
+    PathBuf::from("/tmp").join("idea-mcp")
 }
 
 /// **Single source of truth.** Computes the deterministic loopback endpoint of a

crates/app-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "IdeA",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "identifier": "app.idea.ide",
   "build": {
     "frontendDist": "../../frontend/dist",

crates/app-tauri/tests/dto_agents.rs

@@ -9,7 +9,9 @@ use app_tauri_lib::dto::{
 };
 use application::AppError;
 use application::{
-    CreateAgentOutput, InspectConversationOutput, LaunchAgentOutput, ListAgentsOutput,
+    AgentTicketState, AgentWorkState, CreateAgentOutput, InspectConversationOutput,
+    LaunchAgentOutput, ListAgentsOutput, LiveSessionKind, LiveWorkSession, ProjectWorkState,
+    TicketWorkSource, TicketWorkStatus,
 };
 use domain::ids::{AgentId, NodeId, ProfileId, SessionId};
 use domain::ports::ConversationDetails;
@@ -197,6 +199,187 @@ fn live_agent_list_dto_serialises_camelcase_array() {
     assert!(arr[0].get("node_id").is_none());
 }
 
+#[test]
+fn project_work_state_dto_serialises_live_and_busy_camelcase() {
+    let agent = AgentId::from_uuid(Uuid::from_u128(11));
+    let profile = ProfileId::from_uuid(Uuid::from_u128(12));
+    let node = NodeId::from_uuid(Uuid::from_u128(13));
+    let session = SessionId::from_uuid(Uuid::from_u128(14));
+    let ticket = domain::TicketId::from_uuid(Uuid::from_u128(15));
+    let dto = app_tauri_lib::dto::ProjectWorkStateDto::from(ProjectWorkState {
+        agents: vec![AgentWorkState {
+            agent_id: agent,
+            name: "Worker".to_owned(),
+            profile_id: profile,
+            live: Some(LiveWorkSession {
+                node_id: node,
+                session_id: session,
+                kind: LiveSessionKind::Structured,
+            }),
+            busy: domain::AgentBusyState::Busy {
+                ticket,
+                since_ms: 1_234,
+            },
+            tickets: vec![],
+        }],
+        conversations: vec![],
+    });
+
+    let v = serde_json::to_value(&dto).unwrap();
+    assert_eq!(v["agents"][0]["agentId"], agent.to_string());
+    assert_eq!(v["agents"][0]["profileId"], profile.to_string());
+    assert_eq!(v["agents"][0]["live"]["nodeId"], node.to_string());
+    assert_eq!(v["agents"][0]["live"]["sessionId"], session.to_string());
+    assert_eq!(v["agents"][0]["live"]["kind"], "structured");
+    assert_eq!(v["agents"][0]["busy"]["state"], "busy");
+    assert_eq!(v["agents"][0]["busy"]["ticket"], ticket.to_string());
+    assert_eq!(v["agents"][0]["busy"]["sinceMs"], 1_234);
+    assert_eq!(v["agents"][0]["tickets"], json!([]));
+    assert!(v["agents"][0].get("agent_id").is_none());
+    assert!(v["agents"][0]["live"].get("session_id").is_none());
+    assert!(v["agents"][0]["busy"].get("since_ms").is_none());
+}
+
+#[test]
+fn project_work_state_dto_serialises_tickets_camelcase() {
+    let agent = AgentId::from_uuid(Uuid::from_u128(11));
+    let profile = ProfileId::from_uuid(Uuid::from_u128(12));
+    let requester = AgentId::from_uuid(Uuid::from_u128(20));
+    let head_ticket = domain::TicketId::from_uuid(Uuid::from_u128(30));
+    let next_ticket = domain::TicketId::from_uuid(Uuid::from_u128(31));
+    let conversation = domain::ConversationId::from_uuid(Uuid::from_u128(40));
+    let dto = app_tauri_lib::dto::ProjectWorkStateDto::from(ProjectWorkState {
+        agents: vec![AgentWorkState {
+            agent_id: agent,
+            name: "Worker".to_owned(),
+            profile_id: profile,
+            live: None,
+            busy: domain::AgentBusyState::Idle,
+            tickets: vec![
+                AgentTicketState {
+                    ticket_id: head_ticket,
+                    conversation_id: conversation,
+                    position: 0,
+                    status: TicketWorkStatus::InProgress,
+                    source: TicketWorkSource::Agent {
+                        agent_id: requester,
+                    },
+                    requester_label: "Main".to_owned(),
+                    task_preview: "Analyser le module".to_owned(),
+                    task_len: 842,
+                },
+                AgentTicketState {
+                    ticket_id: next_ticket,
+                    conversation_id: conversation,
+                    position: 1,
+                    status: TicketWorkStatus::Queued,
+                    source: TicketWorkSource::Human,
+                    requester_label: "User".to_owned(),
+                    task_preview: "Vérifier".to_owned(),
+                    task_len: 8,
+                },
+            ],
+        }],
+        conversations: vec![],
+    });
+
+    let v = serde_json::to_value(&dto).unwrap();
+    let head = &v["agents"][0]["tickets"][0];
+    assert_eq!(head["ticketId"], head_ticket.to_string());
+    assert_eq!(head["conversationId"], conversation.to_string());
+    assert_eq!(head["position"], 0);
+    assert_eq!(head["status"], "inProgress");
+    assert_eq!(head["source"]["kind"], "agent");
+    assert_eq!(head["source"]["agentId"], requester.to_string());
+    assert_eq!(head["requesterLabel"], "Main");
+    assert_eq!(head["taskPreview"], "Analyser le module");
+    assert_eq!(head["taskLen"], 842);
+    // snake_case must not leak.
+    assert!(head.get("ticket_id").is_none());
+    assert!(head.get("task_preview").is_none());
+    assert!(head["source"].get("agent_id").is_none());
+
+    let next = &v["agents"][0]["tickets"][1];
+    assert_eq!(next["status"], "queued");
+    assert_eq!(next["source"]["kind"], "human");
+    assert!(next["source"].get("agentId").is_none());
+    assert_eq!(next["requesterLabel"], "User");
+}
+
+#[test]
+fn project_work_state_dto_serialises_conversations_camelcase() {
+    use application::{
+        ConversationPreviewStatus, ConversationTurnWorkPreview, ConversationWorkSummary,
+    };
+    use domain::{ConversationId, TurnId, TurnRole};
+
+    let requester = AgentId::from_uuid(Uuid::from_u128(20));
+    let ready_conv = ConversationId::from_uuid(Uuid::from_u128(40));
+    let missing_conv = ConversationId::from_uuid(Uuid::from_u128(41));
+    let up_to = TurnId::from_uuid(Uuid::from_u128(50));
+
+    let dto = app_tauri_lib::dto::ProjectWorkStateDto::from(ProjectWorkState {
+        agents: vec![],
+        conversations: vec![
+            ConversationWorkSummary {
+                conversation_id: ready_conv,
+                status: ConversationPreviewStatus::Ready,
+                objective_preview: Some("Livrer le lot C".to_owned()),
+                summary_preview: Some("Résumé du fil".to_owned()),
+                summary_len: 1024,
+                up_to: Some(up_to),
+                recent_turns: vec![],
+            },
+            ConversationWorkSummary {
+                conversation_id: missing_conv,
+                status: ConversationPreviewStatus::Missing,
+                objective_preview: None,
+                summary_preview: None,
+                summary_len: 0,
+                up_to: None,
+                recent_turns: vec![ConversationTurnWorkPreview {
+                    role: TurnRole::Prompt,
+                    source: TicketWorkSource::Agent {
+                        agent_id: requester,
+                    },
+                    at_ms: 1_700,
+                    text_preview: "Analyse le module".to_owned(),
+                    text_len: 17,
+                }],
+            },
+        ],
+    });
+
+    let v = serde_json::to_value(&dto).unwrap();
+    let ready = &v["conversations"][0];
+    assert_eq!(ready["conversationId"], ready_conv.to_string());
+    assert_eq!(ready["status"], "ready");
+    assert_eq!(ready["objectivePreview"], "Livrer le lot C");
+    assert_eq!(ready["summaryPreview"], "Résumé du fil");
+    assert_eq!(ready["summaryLen"], 1024);
+    assert_eq!(ready["upTo"], up_to.to_string());
+    assert_eq!(ready["recentTurns"], json!([]));
+    // No snake_case leak.
+    assert!(ready.get("conversation_id").is_none());
+    assert!(ready.get("summary_preview").is_none());
+    assert!(ready.get("up_to").is_none());
+
+    let missing = &v["conversations"][1];
+    assert_eq!(missing["status"], "missing");
+    // Absent previews surface as null (predictable, not omitted).
+    assert!(missing["summaryPreview"].is_null());
+    assert!(missing["upTo"].is_null());
+    let turn = &missing["recentTurns"][0];
+    assert_eq!(turn["role"], "prompt");
+    assert_eq!(turn["source"]["kind"], "agent");
+    assert_eq!(turn["source"]["agentId"], requester.to_string());
+    assert_eq!(turn["atMs"], 1_700);
+    assert_eq!(turn["textPreview"], "Analyse le module");
+    assert_eq!(turn["textLen"], 17);
+    assert!(turn.get("at_ms").is_none());
+    assert!(turn.get("text_preview").is_none());
+}
+
 #[test]
 fn launch_agent_request_carries_conversation_id_for_resume() {
     let raw = json!({
@@ -309,6 +492,7 @@ fn launch_agent_output_maps_to_terminal_session_dto() {
         assigned_conversation_id: None,
         engine_session_id: None,
         structured: None,
+        profile: None,
     };
     let dto = TerminalSessionDto::from(out);
 
@@ -354,6 +538,7 @@ fn launch_agent_output_propagates_assigned_conversation_id() {
         assigned_conversation_id: Some("conv-xyz".to_owned()),
         engine_session_id: None,
         structured: None,
+        profile: None,
     };
     let dto = TerminalSessionDto::from(out);
 
@@ -367,3 +552,82 @@ fn launch_agent_output_propagates_assigned_conversation_id() {
         "no snake_case leak"
     );
 }
+
+// ---------------------------------------------------------------------------
+// Lot D — attach/stop live agent DTOs (controlled actions)
+// ---------------------------------------------------------------------------
+
+#[test]
+fn attach_live_agent_request_deserialises_camelcase() {
+    use app_tauri_lib::dto::AttachLiveAgentRequestDto;
+
+    let raw = json!({
+        "projectId": Uuid::from_u128(1).to_string(),
+        "agentId": Uuid::from_u128(2).to_string(),
+        "nodeId": Uuid::from_u128(3).to_string()
+    });
+    let dto: AttachLiveAgentRequestDto = serde_json::from_value(raw).unwrap();
+    assert_eq!(dto.project_id, Uuid::from_u128(1).to_string());
+    assert_eq!(dto.agent_id, Uuid::from_u128(2).to_string());
+    assert_eq!(dto.node_id, Uuid::from_u128(3).to_string());
+}
+
+#[test]
+fn attach_live_agent_response_serialises_camelcase_with_kind() {
+    use app_tauri_lib::dto::AttachLiveAgentResponseDto;
+    use application::{AttachLiveAgentOutput, LiveSessionKind};
+
+    let agent = AgentId::from_uuid(Uuid::from_u128(11));
+    let node = NodeId::from_uuid(Uuid::from_u128(12));
+    let session = SessionId::from_uuid(Uuid::from_u128(13));
+    let dto = AttachLiveAgentResponseDto::from(AttachLiveAgentOutput {
+        agent_id: agent,
+        node_id: node,
+        session_id: session,
+        kind: LiveSessionKind::Pty,
+    });
+
+    let v = serde_json::to_value(&dto).unwrap();
+    assert_eq!(v["agentId"], agent.to_string());
+    assert_eq!(v["nodeId"], node.to_string());
+    assert_eq!(v["sessionId"], session.to_string());
+    assert_eq!(v["kind"], "pty");
+    // No snake_case leak.
+    assert!(v.get("agent_id").is_none());
+    assert!(v.get("session_id").is_none());
+}
+
+#[test]
+fn stop_live_agent_request_deserialises_camelcase() {
+    use app_tauri_lib::dto::StopLiveAgentRequestDto;
+
+    let raw = json!({
+        "projectId": Uuid::from_u128(1).to_string(),
+        "agentId": Uuid::from_u128(2).to_string()
+    });
+    let dto: StopLiveAgentRequestDto = serde_json::from_value(raw).unwrap();
+    assert_eq!(dto.project_id, Uuid::from_u128(1).to_string());
+    assert_eq!(dto.agent_id, Uuid::from_u128(2).to_string());
+}
+
+#[test]
+fn stop_live_agent_response_serialises_camelcase_with_kind() {
+    use app_tauri_lib::dto::StopLiveAgentResponseDto;
+    use application::{LiveSessionKind, StopLiveAgentOutput};
+
+    let agent = AgentId::from_uuid(Uuid::from_u128(11));
+    let session = SessionId::from_uuid(Uuid::from_u128(13));
+    let dto = StopLiveAgentResponseDto::from(StopLiveAgentOutput {
+        agent_id: agent,
+        session_id: session,
+        kind: LiveSessionKind::Structured,
+    });
+
+    let v = serde_json::to_value(&dto).unwrap();
+    assert_eq!(v["agentId"], agent.to_string());
+    assert_eq!(v["sessionId"], session.to_string());
+    assert_eq!(v["kind"], "structured");
+    // Stop response carries no node id (the session is gone).
+    assert!(v.get("nodeId").is_none());
+    assert!(v.get("session_id").is_none());
+}

crates/app-tauri/tests/dto_chat.rs

@@ -157,6 +157,7 @@ fn launch_output_with_structured_descriptor_derives_chat_cell_kind() {
         assigned_conversation_id: None,
         engine_session_id: None,
         structured: Some(descriptor),
+        profile: None,
     };
     let dto = TerminalSessionDto::from(out);
     assert_eq!(dto.cell_kind, CellKind::Chat);
@@ -173,6 +174,7 @@ fn launch_output_without_structured_descriptor_derives_pty_cell_kind() {
         assigned_conversation_id: None,
         engine_session_id: None,
         structured: None,
+        profile: None,
     };
     let dto = TerminalSessionDto::from(out);
     assert_eq!(dto.cell_kind, CellKind::Pty, "no descriptor ⇒ pty");
@@ -207,6 +209,7 @@ fn pty_launch_output_serialises_cellkind_pty_without_breaking_existing_keys() {
         assigned_conversation_id: None,
         engine_session_id: None,
         structured: None,
+        profile: None,
     };
     let v = serde_json::to_value(TerminalSessionDto::from(out)).unwrap();
     assert_eq!(v["sessionId"], sid.to_string());

crates/app-tauri/tests/session_limit_wiring.rs

@@ -0,0 +1,176 @@
+//! Integration test for the **session-limit** wiring in the composition root
+//! (ARCHITECTURE §21, LS7).
+//!
+//! Proves that [`AppState`] actually *constructs and wires* the
+//! `SessionLimitService` (the gap LS7 closes: the LS1–LS4 domain/application
+//! machinery existed but was never instantiated at runtime). The detect→plan→
+//! resume→cancel logic itself is covered by the application/infrastructure unit
+//! tests (LS3/LS4); here we assert the **composition** the commands rely on:
+//! the service is present, `on_rate_limited` arms a cancellable resume that emits
+//! the domain events on the real bus, and `cancel_resume` is a clean no-op for an
+//! unknown agent (never a panic).
+
+use std::path::PathBuf;
+use std::time::Duration;
+
+use app_tauri_lib::state::AppState;
+use domain::events::DomainEvent;
+use domain::ids::NodeId;
+use domain::ports::IdGenerator;
+use domain::AgentId;
+use infrastructure::UuidGenerator;
+
+fn temp_path(tag: &str) -> PathBuf {
+    let ids = UuidGenerator::new();
+    std::env::temp_dir().join(format!("idea-sl-test-{tag}-{}", ids.new_uuid()))
+}
+
+fn agent(n: u128) -> AgentId {
+    AgentId::from_uuid(uuid::Uuid::from_u128(n))
+}
+
+fn node(n: u128) -> NodeId {
+    NodeId::from_uuid(uuid::Uuid::from_u128(n))
+}
+
+/// `cancel_resume` on an agent with no armed resume returns `false` (and never
+/// panics): the service is wired and behaves as a clean no-op.
+#[tokio::test]
+async fn cancel_resume_is_a_clean_noop_for_unknown_agent() {
+    let state = AppState::build(temp_path("appdata"));
+    assert!(
+        !state.session_limit_service.cancel_resume(agent(1)),
+        "no armed resume ⇒ cancel returns false"
+    );
+}
+
+/// A structured rate-limit signal with a **future** reset arms a cancellable
+/// resume: the wired service publishes `AgentRateLimited` then
+/// `AgentResumeScheduled` on the **real** event bus, and `cancel_resume` then
+/// publishes `AgentResumeCancelled` and returns `true`.
+#[tokio::test]
+async fn on_rate_limited_arms_a_cancellable_resume_over_the_real_bus() {
+    let state = AppState::build(temp_path("appdata"));
+    let mut rx = state.event_bus.raw_receiver();
+
+    // Reset far in the future so the scheduler does NOT fire before we cancel.
+    let resets_at_ms = i64::MAX;
+    state
+        .session_limit_service
+        .on_rate_limited(agent(7), node(70), None, Some(resets_at_ms));
+
+    // The two arming events, in order, on the bus.
+    let mut saw_rate_limited = false;
+    let mut saw_scheduled = false;
+    for _ in 0..32 {
+        match tokio::time::timeout(Duration::from_secs(2), rx.recv()).await {
+            Ok(Ok(DomainEvent::AgentRateLimited { agent_id, .. })) if agent_id == agent(7) => {
+                saw_rate_limited = true;
+            }
+            Ok(Ok(DomainEvent::AgentResumeScheduled { agent_id, .. })) if agent_id == agent(7) => {
+                saw_scheduled = true;
+                break;
+            }
+            Ok(Ok(_)) => continue,
+            _ => break,
+        }
+    }
+    assert!(saw_rate_limited, "AgentRateLimited relayed on the bus");
+    assert!(saw_scheduled, "AgentResumeScheduled relayed on the bus");
+
+    // The window is cancellable: cancel succeeds and emits AgentResumeCancelled.
+    assert!(
+        state.session_limit_service.cancel_resume(agent(7)),
+        "an armed resume is cancellable"
+    );
+    let mut saw_cancelled = false;
+    for _ in 0..32 {
+        match tokio::time::timeout(Duration::from_secs(2), rx.recv()).await {
+            Ok(Ok(DomainEvent::AgentResumeCancelled { agent_id })) if agent_id == agent(7) => {
+                saw_cancelled = true;
+                break;
+            }
+            Ok(Ok(_)) => continue,
+            _ => break,
+        }
+    }
+    assert!(saw_cancelled, "AgentResumeCancelled relayed on the bus");
+}
+
+/// `set_resume_at` (filet humain niveau 3) résout l'agent→cellule dans les registries
+/// des sessions vivantes ; **sans cellule vivante**, la résolution échoue ⇒ la commande
+/// renvoie `NOT_FOUND` sans armer quoi que ce soit (pas d'armement orphelin).
+///
+/// La commande `#[tauri::command]` exige une `State<AppState>` non constructible hors
+/// runtime Tauri ; on couvre donc ici sa **précondition exacte** : sur un `AppState`
+/// neuf (aucune session vivante), aucune registry ne résout l'agent — c'est précisément
+/// le `None` qui produit le `NOT_FOUND` dans `set_resume_at` (cf. commands.rs:1420-1428).
+#[tokio::test]
+async fn set_resume_at_resolves_no_cell_for_an_agent_without_a_live_session() {
+    let state = AppState::build(temp_path("appdata"));
+    let unknown = agent(99);
+
+    assert!(
+        state.structured_sessions.node_for_agent(&unknown).is_none(),
+        "aucune session structurée vivante ⇒ pas de cellule"
+    );
+    assert!(
+        state.terminal_sessions.node_for_agent(&unknown).is_none(),
+        "aucune session terminal vivante ⇒ pas de cellule"
+    );
+    // Conjonction = la branche `ok_or_else(NotFound)` de set_resume_at est prise :
+    // la saisie d'heure n'a pas de cible ⇒ aucun armement orphelin.
+    let resolved = state
+        .structured_sessions
+        .node_for_agent(&unknown)
+        .or_else(|| state.terminal_sessions.node_for_agent(&unknown));
+    assert!(
+        resolved.is_none(),
+        "set_resume_at ⇒ NOT_FOUND (aucun armement orphelin)"
+    );
+}
+
+/// Parité runtime du filet humain : `confirm_human_resume` (la délégation de
+/// `set_resume_at`) arme une reprise annulable sur le **vrai** bus — `AgentRateLimited`
+/// puis `AgentResumeScheduled` — exactement comme la branche auto `on_rate_limited`.
+#[tokio::test]
+async fn confirm_human_resume_arms_a_cancellable_resume_over_the_real_bus() {
+    let state = AppState::build(temp_path("appdata"));
+    let mut rx = state.event_bus.raw_receiver();
+
+    // Reset très loin dans le futur : le scheduler ne tire pas avant l'annulation.
+    let resets_at_ms = i64::MAX;
+    state
+        .session_limit_service
+        .confirm_human_resume(agent(8), node(80), None, resets_at_ms);
+
+    let mut saw_rate_limited = false;
+    let mut saw_scheduled = false;
+    for _ in 0..32 {
+        match tokio::time::timeout(Duration::from_secs(2), rx.recv()).await {
+            Ok(Ok(DomainEvent::AgentRateLimited { agent_id, .. })) if agent_id == agent(8) => {
+                saw_rate_limited = true;
+            }
+            Ok(Ok(DomainEvent::AgentResumeScheduled { agent_id, .. })) if agent_id == agent(8) => {
+                saw_scheduled = true;
+                break;
+            }
+            Ok(Ok(_)) => continue,
+            _ => break,
+        }
+    }
+    assert!(
+        saw_rate_limited,
+        "AgentRateLimited relayed on the bus (humain)"
+    );
+    assert!(
+        saw_scheduled,
+        "AgentResumeScheduled relayed on the bus (humain)"
+    );
+
+    // Annulable par la même voie que l'auto.
+    assert!(
+        state.session_limit_service.cancel_resume(agent(8)),
+        "an armed human resume is cancellable"
+    );
+}

crates/application/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "application"
-version = "0.1.0"
+version = "0.3.0"
 edition.workspace = true
 license.workspace = true
 rust-version.workspace = true

crates/application/src/agent/catalogue.rs

@@ -24,6 +24,11 @@ use domain::profile::{
     StructuredAdapter,
 };
 
+/// Codex's interactive TUI is sensitive to receiving a large pasted block and the
+/// submit key too close together. Keep the default conservative so delegated
+/// prompts are actually submitted instead of remaining in the input editor.
+pub const CODEX_SUBMIT_DELAY_MS: u32 = 350;
+
 /// A fixed UUID namespace used to derive stable ids for reference profiles.
 /// (Random-looking but constant; only its stability matters.)
 const REFERENCE_NAMESPACE: uuid::Uuid = uuid::uuid!("6f9b1d2a-7c34-4e58-9a1b-2c3d4e5f6a7b");
@@ -82,6 +87,7 @@ pub fn reference_profiles() -> Vec<AgentProfile> {
         .expect("codex reference profile is valid")
         .with_structured_adapter(StructuredAdapter::Codex)
         .with_projector(ProjectorKey::Codex)
+        .with_submit_delay_ms(CODEX_SUBMIT_DELAY_MS)
         .with_mcp(McpCapability::new(
             // Codex lit ses serveurs MCP dans `$CODEX_HOME/config.toml`, pas `.mcp.json` :
             // IdeA écrit ce TOML DANS le run dir et pointe `CODEX_HOME` dessus pour

crates/application/src/agent/mod.rs

@@ -10,23 +10,31 @@ mod catalogue;
 mod inspect;
 mod lifecycle;
 mod resume;
+mod session_limit;
 mod structured;
 mod usecases;
 
 pub(crate) use lifecycle::unique_md_path;
 pub(crate) use lifecycle::ReattachDecision;
 
-pub use structured::{drain_with_readiness, send_blocking};
+pub use session_limit::{AgentResumer, SessionLimitService, RESUME_PROMPT};
+pub use structured::{
+    drain_with_readiness, drain_with_readiness_outcome, send_blocking, TurnOutcome,
+};
 
-pub use catalogue::{reference_profile_id, reference_profiles, selectable_reference_profiles};
+pub use catalogue::{
+    reference_profile_id, reference_profiles,
+    selectable_reference_profiles, CODEX_SUBMIT_DELAY_MS,
+};
 pub use inspect::{InspectConversation, InspectConversationInput, InspectConversationOutput};
 pub use lifecycle::{
     ChangeAgentProfile, ChangeAgentProfileInput, ChangeAgentProfileOutput, CreateAgentFromScratch,
     CreateAgentInput, CreateAgentOutput, DeleteAgent, DeleteAgentInput, HandoffProvider,
-    LaunchAgent, LaunchAgentInput, LaunchAgentOutput, ListAgents, ListAgentsInput,
-    ListAgentsOutput, McpRuntime, PermissionProjectorRegistry, ProviderSessionProvider,
-    ReadAgentContext, ReadAgentContextInput, ReadAgentContextOutput, StructuredSessionDescriptor,
-    UpdateAgentContext, UpdateAgentContextInput, AGENT_MEMORY_RECALL_BUDGET,
+    InjectedLiveRow, LaunchAgent, LaunchAgentInput, LaunchAgentOutput, ListAgents, ListAgentsInput,
+    ListAgentsOutput, LiveStateLeanProvider, McpRuntime, PermissionProjectorRegistry,
+    ProviderSessionProvider, ReadAgentContext, ReadAgentContextInput, ReadAgentContextOutput,
+    StructuredSessionDescriptor, UpdateAgentContext, UpdateAgentContextInput,
+    AGENT_MEMORY_RECALL_BUDGET, LIVE_STATE_INJECT_MAX,
 };
 pub use resume::{
     ListResumableAgents, ListResumableAgentsInput, ListResumableAgentsOutput, ResumableAgent,

crates/application/src/agent/session_limit.rs

@@ -0,0 +1,294 @@
+//! [`SessionLimitService`] — orchestration applicative des **limites de session**
+//! des agents (ARCHITECTURE §21.5) : **détecter → planifier → reprendre**, et
+//! **annuler**.
+//!
+//! Service **pur-ports** (SOLID/hexagonal) : il ne dépend que de traits du domaine
+//! ([`Clock`], [`Scheduler`], [`EventBus`]) et d'un port applicatif de reprise
+//! ([`AgentResumer`], implémenté au composition root en LS7 par-dessus `LaunchAgent`).
+//! Aucune dépendance vers un adapter concret ⇒ entièrement testable avec des fakes.
+//!
+//! # État en mémoire uniquement (§21.1-3)
+//!
+//! La seule mémoire du service est une table `agent_id → ScheduleId` des reprises
+//! **armées** (pour pouvoir les annuler). Aucune persistance : à un redémarrage
+//! d'IdeA le chemin `ListResumableAgents` existant prend le relais.
+//!
+//! # Dédoublonnage par agent (§21.10-4)
+//!
+//! Un agent n'a qu'**une** reprise armée à la fois : un second signal de limite
+//! **rafraîchit** l'armement (annule l'ancien, arme le nouveau) au lieu d'empiler.
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+use async_trait::async_trait;
+
+use domain::ids::{AgentId, NodeId, ScheduleId};
+use domain::ports::{Clock, EventBus, ScheduledTask, Scheduler};
+use domain::session_limit::{plan_resume, RateLimitSource, ResumePlan, SessionLimit};
+use domain::DomainEvent;
+
+use crate::error::AppError;
+
+/// Prompt **court** envoyé à l'agent au moment de la reprise automatique (§21.5).
+///
+/// `--resume` (via [`domain::ports::SessionPlan::Resume`]) porte déjà tout
+/// l'historique : ce prompt n'a qu'à **réamorcer** le tour, pas reconstruire le
+/// contexte. Volontairement neutre et model-agnostique.
+pub const RESUME_PROMPT: &str = "La limite de session est levée. Reprends là où tu t'étais arrêté.";
+
+/// Port applicatif de **reprise d'un agent** (frontière implémentée au composition
+/// root, LS7). Calqué sur les autres traits-passerelles de l'application
+/// ([`crate::agent::HandoffProvider`], [`crate::agent::ProviderSessionProvider`]) :
+/// l'app-tauri le branche par-dessus le mécanisme de lancement existant
+/// (`LaunchAgent` + `AgentSessionFactory`) avec [`domain::ports::SessionPlan::Resume`].
+///
+/// Le service ne sait **pas** relancer un agent lui-même (cela exige le `Project`, le
+/// profil, le contexte préparé, le PTY… que seul `LaunchAgent` résout) ; il délègue
+/// donc à ce port, en restant testable avec un fake.
+#[async_trait]
+pub trait AgentResumer: Send + Sync {
+    /// Relance/réattache l'agent `agent_id` dans sa cellule `node_id`, en reprenant la
+    /// conversation moteur `conversation_id` (`SessionPlan::Resume` côté lancement) et
+    /// en lui transmettant `resume_prompt` comme premier tour.
+    ///
+    /// # Errors
+    /// [`AppError`] si la relance échoue (profil/contexte introuvable, échec de
+    /// démarrage de session…). Le service propage l'erreur sans publier `AgentResumed`.
+    async fn resume(
+        &self,
+        agent_id: AgentId,
+        node_id: NodeId,
+        conversation_id: Option<String>,
+        resume_prompt: &str,
+    ) -> Result<(), AppError>;
+}
+
+/// Service d'orchestration des limites de session (§21.5).
+pub struct SessionLimitService {
+    clock: Arc<dyn Clock>,
+    scheduler: Arc<dyn Scheduler>,
+    events: Arc<dyn EventBus>,
+    resumer: Arc<dyn AgentResumer>,
+    /// Reprises **armées** non encore tirées : `agent_id → ScheduleId` (en mémoire).
+    armed: Mutex<HashMap<AgentId, ScheduleId>>,
+}
+
+impl SessionLimitService {
+    /// Construit le service depuis ses ports injectés (composition root).
+    #[must_use]
+    pub fn new(
+        clock: Arc<dyn Clock>,
+        scheduler: Arc<dyn Scheduler>,
+        events: Arc<dyn EventBus>,
+        resumer: Arc<dyn AgentResumer>,
+    ) -> Self {
+        Self {
+            clock,
+            scheduler,
+            events,
+            resumer,
+            armed: Mutex::new(HashMap::new()),
+        }
+    }
+
+    /// **(a) Détection → planification.** À partir d'un signal de limite
+    /// (`ReadinessSignal::RateLimited`/`TurnOutcome::RateLimited`) pour `agent_id` dans
+    /// la cellule `node_id`, construit un [`SessionLimit`] (source `Structured`),
+    /// calcule le plan via [`plan_resume`] et agit :
+    ///
+    /// - [`ResumePlan::Scheduled`] ⇒ publie `AgentRateLimited`, **arme** la reprise via
+    ///   [`Scheduler::arm`] (dédoublonnée : un éventuel armement antérieur du même agent
+    ///   est annulé d'abord, §21.10-4), mémorise le [`ScheduleId`], puis publie
+    ///   `AgentResumeScheduled`.
+    /// - [`ResumePlan::HumanFallback`] (heure de reset inconnue) ⇒ publie
+    ///   `AgentRateLimited{None}` puis `AgentRateLimitSuspected{None}` (filet humain ;
+    ///   la confirmation UI est LS6/LS8 — ici on émet seulement l'événement).
+    pub fn on_rate_limited(
+        &self,
+        agent_id: AgentId,
+        node_id: NodeId,
+        conversation_id: Option<String>,
+        resets_at_ms: Option<i64>,
+    ) {
+        let now = self.clock.now_millis();
+        let limit = SessionLimit::new(resets_at_ms, now, RateLimitSource::Structured);
+
+        match plan_resume(now, &limit, conversation_id) {
+            ResumePlan::Scheduled {
+                fire_at_ms,
+                conversation_id,
+            } => {
+                self.arm_scheduled(agent_id, fire_at_ms, node_id, conversation_id, resets_at_ms);
+            }
+            ResumePlan::HumanFallback => {
+                self.events.publish(DomainEvent::AgentRateLimited {
+                    agent_id,
+                    resets_at_ms: None,
+                });
+                self.events.publish(DomainEvent::AgentRateLimitSuspected {
+                    agent_id,
+                    resets_at_ms: None,
+                });
+            }
+        }
+    }
+
+    /// **(d) Filet humain (§21.1 niveau 3).** L'utilisateur a saisi l'heure de reset
+    /// pour un agent en limite **suspectée** (rien n'a matché automatiquement). On
+    /// construit une [`SessionLimit`] de source [`RateLimitSource::Human`], on calcule
+    /// le plan via [`plan_resume`] et on **arme exactement la même reprise** que la
+    /// branche auto : mêmes événements (`AgentRateLimited{Some}` + `AgentResumeScheduled`),
+    /// même dédoublonnage, même annulabilité via [`Self::cancel_resume`].
+    ///
+    /// L'heure saisie est traitée par le domaine sans privilège particulier : un reset
+    /// déjà passé est clampé à `now` par [`plan_resume`] ⇒ reprise immédiate. Le cas
+    /// [`ResumePlan::HumanFallback`] est ici inatteignable (`resets_at_ms` est toujours
+    /// `Some`) ; on le traite en no-op défensif pour rester total.
+    pub fn confirm_human_resume(
+        &self,
+        agent_id: AgentId,
+        node_id: NodeId,
+        conversation_id: Option<String>,
+        resets_at_ms: i64,
+    ) {
+        let now = self.clock.now_millis();
+        let limit = SessionLimit::new(Some(resets_at_ms), now, RateLimitSource::Human);
+
+        if let ResumePlan::Scheduled {
+            fire_at_ms,
+            conversation_id,
+        } = plan_resume(now, &limit, conversation_id)
+        {
+            self.arm_scheduled(
+                agent_id,
+                fire_at_ms,
+                node_id,
+                conversation_id,
+                Some(resets_at_ms),
+            );
+        }
+    }
+
+    /// Arme (ou ré-arme) une reprise **programmée** pour `agent_id`, fabrique commune aux
+    /// deux entrées (auto §21.1 niveaux 1/2 et filet humain niveau 3). Séquence stricte,
+    /// identique à l'origine — d'où **zéro régression** : publie `AgentRateLimited`
+    /// (avec l'heure de reset connue), **dédoublonne** l'armement précédent via
+    /// [`Self::disarm`] (interne, sans événement), arme le réveil via [`Scheduler::arm`],
+    /// mémorise le [`ScheduleId`], puis publie `AgentResumeScheduled`.
+    ///
+    /// `resets_at_ms` est l'heure de reset **annoncée à l'UI** (countdown) ; `fire_at_ms`
+    /// est l'échéance effective (déjà clampée anti-passé par le domaine). Les deux ne
+    /// coïncident que si le reset est futur — on conserve donc la sémantique d'origine en
+    /// publiant l'heure de reset brute, pas l'échéance clampée.
+    fn arm_scheduled(
+        &self,
+        agent_id: AgentId,
+        fire_at_ms: i64,
+        node_id: NodeId,
+        conversation_id: Option<String>,
+        resets_at_ms: Option<i64>,
+    ) {
+        self.events.publish(DomainEvent::AgentRateLimited {
+            agent_id,
+            resets_at_ms,
+        });
+        // Dédoublonnage (§21.10-4) : un signal de rafraîchissement annule
+        // l'armement précédent (sans événement d'annulation : c'est interne).
+        self.disarm(agent_id);
+        let id = self.scheduler.arm(
+            fire_at_ms,
+            ScheduledTask::ResumeAgent {
+                agent_id,
+                node_id,
+                conversation_id,
+            },
+        );
+        self.armed
+            .lock()
+            .expect("session-limit mutex sain")
+            .insert(agent_id, id);
+        self.events.publish(DomainEvent::AgentResumeScheduled {
+            agent_id,
+            fire_at_ms,
+        });
+    }
+
+    /// **(b) Exécution de la reprise.** Consomme une [`ScheduledTask::ResumeAgent`]
+    /// échue (celle que `TokioScheduler` pousse dans le canal de remise ; le câblage du
+    /// récepteur dans le runtime est LS7). Retire l'entrée armée (le réveil a tiré),
+    /// relance l'agent via [`AgentResumer`] avec [`RESUME_PROMPT`], puis publie
+    /// `AgentResumed`.
+    ///
+    /// # Errors
+    /// [`AppError`] propagée par [`AgentResumer::resume`] (la relance a échoué) ; dans
+    /// ce cas `AgentResumed` n'est **pas** publié.
+    pub async fn execute_resume(&self, task: ScheduledTask) -> Result<(), AppError> {
+        let ScheduledTask::ResumeAgent {
+            agent_id,
+            node_id,
+            conversation_id,
+        } = task;
+
+        // Le réveil a tiré : l'entrée armée n'a plus lieu d'être (qu'on réussisse ou non).
+        self.disarm(agent_id);
+
+        self.resumer
+            .resume(agent_id, node_id, conversation_id, RESUME_PROMPT)
+            .await?;
+
+        self.events.publish(DomainEvent::AgentResumed { agent_id });
+        Ok(())
+    }
+
+    /// **(c) Annulation.** Désarme la reprise auto de `agent_id` (socle du « annulable »).
+    /// Retrouve le [`ScheduleId`], appelle [`Scheduler::cancel`] et, **seulement si**
+    /// l'annulation a réussi, retire l'entrée et publie `AgentResumeCancelled`.
+    ///
+    /// Renvoie `true` ssi la reprise a effectivement été annulée.
+    ///
+    /// # Course « cancel pile au tir » (vigilance QA, LS3)
+    /// Sous runtime multi-thread, le réveil peut tirer **pile** au moment de l'annulation :
+    /// [`Scheduler::cancel`] renvoie alors `false` (déjà tiré). Dans ce cas on **ne
+    /// publie pas** `AgentResumeCancelled` et on **laisse l'entrée** (l'`execute_resume`
+    /// en cours la retirera) : la reprise **suit son cours**, cohérent et sans
+    /// événement trompeur.
+    pub fn cancel_resume(&self, agent_id: AgentId) -> bool {
+        let id = self
+            .armed
+            .lock()
+            .expect("session-limit mutex sain")
+            .get(&agent_id)
+            .copied();
+        let Some(id) = id else {
+            return false; // aucune reprise armée pour cet agent.
+        };
+
+        if self.scheduler.cancel(id) {
+            self.armed
+                .lock()
+                .expect("session-limit mutex sain")
+                .remove(&agent_id);
+            self.events
+                .publish(DomainEvent::AgentResumeCancelled { agent_id });
+            true
+        } else {
+            // Déjà tiré : la reprise suivra son cours, pas d'événement d'annulation.
+            false
+        }
+    }
+
+    /// Retire (best-effort) l'armement de `agent_id` et annule le réveil sous-jacent
+    /// s'il existe. Usage interne (rafraîchissement / nettoyage post-tir) — **ne publie
+    /// aucun événement** (contrairement à [`Self::cancel_resume`]).
+    fn disarm(&self, agent_id: AgentId) {
+        let previous = self
+            .armed
+            .lock()
+            .expect("session-limit mutex sain")
+            .remove(&agent_id);
+        if let Some(id) = previous {
+            self.scheduler.cancel(id);
+        }
+    }
+}

crates/application/src/agent/structured.rs

@@ -14,11 +14,36 @@
 
 use std::time::Duration;
 
-use domain::input::InputMediator;
 use domain::ids::AgentId;
+use domain::input::InputMediator;
 use domain::ports::{AgentSession, AgentSessionError, ReplyEvent};
 use domain::readiness::{ReadinessPolicy, ReadinessSignal};
 
+/// Issue d'un tour drainé (ARCHITECTURE §21.2-T4, réconciliation de la limite de
+/// session avec le contrat « seul `Final` est terminal »).
+///
+/// Un tour se termine de deux façons **gracieuses** :
+/// - [`TurnOutcome::Completed`] : le flux a rendu son [`ReplyEvent::Final`] — fin
+///   déterministe normale (cas historique, contenu agrégé) ;
+/// - [`TurnOutcome::RateLimited`] : le flux s'est **clos sans `Final`** *parce que*
+///   l'agent est entré en **limite de session** (un [`ReplyEvent::RateLimited`] a été
+///   observé dans le tour). Ce n'est **pas** une erreur (§21.2-T4) : l'agent reste
+///   vivant, le service de limite (lot LS4) arme la reprise.
+///
+/// Un flux clos **sans `Final` ET sans `RateLimited`** reste une **erreur**
+/// [`AgentSessionError::Io`] (tour réellement interrompu) — comportement inchangé.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TurnOutcome {
+    /// Tour terminé normalement par un `Final` ; porte le contenu agrégé.
+    Completed(String),
+    /// Tour clos sur une **limite de session** (sans `Final`) ; porte l'heure de
+    /// reset éventuelle (époche-ms) telle que vue dans le dernier `RateLimited`.
+    RateLimited {
+        /// Instant de reset en époche-ms (`None` ⇒ heure inconnue ⇒ filet humain).
+        resets_at_ms: Option<i64>,
+    },
+}
+
 /// Envoie `prompt` à la session vivante puis **draine le flux de réponse jusqu'au
 /// [`ReplyEvent::Final`]**, et retourne son contenu agrégé.
 ///
@@ -36,14 +61,23 @@ use domain::readiness::{ReadinessPolicy, ReadinessSignal};
 /// - [`AgentSessionError::Io`]/[`AgentSessionError::Decode`] remontées par `send`
 ///   (échec de communication / décodage de la sortie structurée) ;
 /// - [`AgentSessionError::Io`] si le flux se termine **sans** `Final` (tour
-///   interrompu) ;
+///   interrompu) — y compris un tour clos sur une **limite de session** (le
+///   rendez-vous synchrone n'a pas de contenu à rendre ; cf. [`TurnOutcome`] et la
+///   variante riche [`drain_with_readiness_outcome`] pour exploiter la limite) ;
 /// - [`AgentSessionError::Timeout`] si `timeout` expire avant le `Final`.
 pub async fn send_blocking(
     session: &dyn AgentSession,
     prompt: &str,
     timeout: Option<Duration>,
 ) -> Result<String, AgentSessionError> {
-    drain_bounded_events(session, prompt, timeout, |_event| {}, |_signal| {}).await
+    match drain_bounded_events(session, prompt, timeout, |_event| {}, |_signal| {}).await? {
+        TurnOutcome::Completed(content) => Ok(content),
+        // Le rendez-vous synchrone (ask) attend un contenu : un tour limité n'en a pas
+        // ⇒ on conserve le comportement historique (erreur), sans casser le contrat.
+        TurnOutcome::RateLimited { .. } => Err(AgentSessionError::Io(
+            "le tour s'est clos en limite de session, sans contenu Final".to_string(),
+        )),
+    }
 }
 
 /// Comme [`send_blocking`], mais **branche la readiness** : à chaque événement du
@@ -61,7 +95,9 @@ pub async fn send_blocking(
 ///
 /// # Errors
 /// Identiques à [`send_blocking`] (échec `send`/décodage, flux clos sans `Final`,
-/// timeout).
+/// timeout). Un tour clos sur une **limite de session** ⇒ [`AgentSessionError::Io`]
+/// **ici** (signature historique `Result<String>`, zéro régression pour l'appelant
+/// orchestrateur) ; utilise [`drain_with_readiness_outcome`] pour exploiter la limite.
 pub async fn drain_with_readiness(
     session: &dyn AgentSession,
     prompt: &str,
@@ -69,6 +105,38 @@ pub async fn drain_with_readiness(
     mediator: &dyn InputMediator,
     agent: AgentId,
 ) -> Result<String, AgentSessionError> {
+    match drain_with_readiness_outcome(session, prompt, timeout, mediator, agent).await? {
+        TurnOutcome::Completed(content) => Ok(content),
+        TurnOutcome::RateLimited { .. } => Err(AgentSessionError::Io(
+            "le tour s'est clos en limite de session, sans contenu Final".to_string(),
+        )),
+    }
+}
+
+/// Variante **riche** de [`drain_with_readiness`] : même branchement readiness, mais
+/// retourne le [`TurnOutcome`] complet au lieu de réduire la limite à une erreur.
+///
+/// C'est le point d'entrée du chemin **conscient de la limite** (réconciliation
+/// §21.2-T4) : sur un tour clos sans `Final` mais ayant vu un
+/// [`ReplyEvent::RateLimited`], il renvoie `Ok(`[`TurnOutcome::RateLimited`]`)` (fin
+/// gracieuse) plutôt qu'une `Io`. Le drain applicatif / le `SessionLimitService`
+/// (LS4) consomment cette issue pour armer la reprise. Le câblage de ce chemin sur
+/// le tour délégué de l'orchestrateur est du ressort de LS7.
+///
+/// **Readiness inchangée** : `mark_idle` reste piloté **uniquement** par le `Final`
+/// (`TurnEnded`) — un `RateLimited` ne marque **pas** l'agent `Idle` (§21.5 : « le
+/// `mark_idle`/FIFO reste piloté par `Final`/timeout »).
+///
+/// # Errors
+/// Comme [`drain_with_readiness`], **sauf** qu'un tour limité n'est plus une erreur
+/// (il devient [`TurnOutcome::RateLimited`]).
+pub async fn drain_with_readiness_outcome(
+    session: &dyn AgentSession,
+    prompt: &str,
+    timeout: Option<Duration>,
+    mediator: &dyn InputMediator,
+    agent: AgentId,
+) -> Result<TurnOutcome, AgentSessionError> {
     // `on_signal` ne reçoit QUE les événements terminaux (le `Final` ⇒ `TurnEnded`) :
     // la readiness ne classe pas les non-terminaux. Pour le **battement** de vivacité
     // (lot 2) on a besoin de notifier le médiateur à CHAQUE événement non terminal
@@ -84,6 +152,8 @@ pub async fn drain_with_readiness(
             }
         },
         |signal| {
+            // Seul le `Final` marque `Idle` : un `RateLimited` ne fait PAS avancer la
+            // FIFO (la reprise est gérée par le service de limite, §21.5).
             if signal == ReadinessSignal::TurnEnded {
                 mediator.mark_idle(agent);
             }
@@ -106,18 +176,17 @@ async fn drain_bounded_events(
     timeout: Option<Duration>,
     on_event: impl FnMut(&ReplyEvent),
     on_signal: impl FnMut(ReadinessSignal),
-) -> Result<String, AgentSessionError> {
+) -> Result<TurnOutcome, AgentSessionError> {
     match timeout {
-        Some(dur) => match tokio::time::timeout(
-            dur,
-            drain_to_final(session, prompt, on_event, on_signal),
-        )
-        .await
-        {
-            Ok(result) => result,
-            // La session **reste vivante** : on ne `shutdown` rien ici (§17.1).
-            Err(_elapsed) => Err(AgentSessionError::Timeout),
-        },
+        Some(dur) => {
+            match tokio::time::timeout(dur, drain_to_final(session, prompt, on_event, on_signal))
+                .await
+            {
+                Ok(result) => result,
+                // La session **reste vivante** : on ne `shutdown` rien ici (§17.1).
+                Err(_elapsed) => Err(AgentSessionError::Timeout),
+            }
+        }
         None => drain_to_final(session, prompt, on_event, on_signal).await,
     }
 }
@@ -126,18 +195,27 @@ async fn drain_bounded_events(
 ///
 /// Le flux ([`domain::ports::ReplyStream`]) est un itérateur synchrone et borné :
 /// après le `Final` il ne produit plus rien. On le parcourt donc simplement
-/// jusqu'à rencontrer le `Final` (et on retourne son contenu) ; si le flux
-/// s'épuise avant, c'est un tour interrompu → erreur [`AgentSessionError::Io`].
+/// jusqu'à rencontrer le `Final` (et on retourne son contenu) ; si le flux s'épuise
+/// avant, l'issue dépend de ce qu'on a vu (réconciliation §21.2-T4) :
+/// - un [`ReplyEvent::RateLimited`] a été observé ⇒ fin **gracieuse**
+///   [`TurnOutcome::RateLimited`] (l'agent est limité, pas en erreur) ;
+/// - sinon ⇒ tour réellement interrompu → erreur [`AgentSessionError::Io`]
+///   (comportement **inchangé**).
 ///
 /// Chaque événement est classé par [`ReadinessPolicy`] et le signal éventuel est
-/// remonté à `on_signal` (le `Final` ⇒ [`ReadinessSignal::TurnEnded`]). Deltas,
-/// activités et heartbeats sont non terminaux ⇒ ignorés par le rendez-vous synchrone.
+/// remonté à `on_signal` (le `Final` ⇒ [`ReadinessSignal::TurnEnded`] ; un
+/// `RateLimited` ⇒ [`ReadinessSignal::RateLimited`]). Deltas, activités et heartbeats
+/// sont non terminaux ⇒ ignorés par le rendez-vous synchrone.
 async fn drain_to_final(
     session: &dyn AgentSession,
     prompt: &str,
     mut on_event: impl FnMut(&ReplyEvent),
     mut on_signal: impl FnMut(ReadinessSignal),
-) -> Result<String, AgentSessionError> {
+) -> Result<TurnOutcome, AgentSessionError> {
+    // Mémorise la dernière limite vue (§21.2-T4) : `Some(resets_at_ms)` dès qu'un
+    // `RateLimited` traverse le flux. Sert UNIQUEMENT au cas « clos sans Final » —
+    // un `Final` ultérieur l'emporte toujours (le tour a réellement abouti).
+    let mut last_rate_limit: Option<Option<i64>> = None;
     let stream = session.send(prompt).await?;
     for event in stream {
         // Battement de vivacité (lot 2) : notifié pour CHAQUE événement brut, avant le
@@ -146,14 +224,23 @@ async fn drain_to_final(
         if let Some(signal) = ReadinessPolicy::classify(&event) {
             on_signal(signal);
         }
-        if let ReplyEvent::Final { content } = event {
-            return Ok(content);
+        match event {
+            ReplyEvent::Final { content } => return Ok(TurnOutcome::Completed(content)),
+            ReplyEvent::RateLimited { resets_at_ms } => last_rate_limit = Some(resets_at_ms),
+            // TextDelta / ToolActivity / Heartbeat : non terminaux, ignorés ici.
+            ReplyEvent::TextDelta { .. }
+            | ReplyEvent::ToolActivity { .. }
+            | ReplyEvent::Heartbeat => {}
         }
-        // TextDelta / ToolActivity / Heartbeat : non terminaux, ignorés ici.
     }
-    Err(AgentSessionError::Io(
-        "le flux de réponse s'est terminé sans événement Final".to_string(),
-    ))
+    // Flux clos sans `Final` : fin gracieuse SI une limite a été vue (§21.2-T4),
+    // sinon erreur comme avant.
+    match last_rate_limit {
+        Some(resets_at_ms) => Ok(TurnOutcome::RateLimited { resets_at_ms }),
+        None => Err(AgentSessionError::Io(
+            "le flux de réponse s'est terminé sans événement Final".to_string(),
+        )),
+    }
 }
 
 #[cfg(test)]
@@ -214,11 +301,10 @@ mod tests {
             AgentBusyState::Idle
         }
         fn bind_handle(&self, _agent: AgentId, _handle: PtyHandle) {}
-        fn bind_handle_with_prompt(
+        fn bind_handle_with_submit(
             &self,
             _agent: AgentId,
             _handle: PtyHandle,
-            _pattern: Option<String>,
             _submit: SubmitConfig,
         ) {
         }
@@ -229,7 +315,9 @@ mod tests {
         let session = FakeSession {
             events: vec![
                 ReplyEvent::TextDelta { text: "a".into() },
-                ReplyEvent::ToolActivity { label: "lit".into() },
+                ReplyEvent::ToolActivity {
+                    label: "lit".into(),
+                },
                 ReplyEvent::Heartbeat,
                 ReplyEvent::Final {
                     content: "fini".into(),

crates/application/src/conversation/mod.rs

@@ -13,6 +13,13 @@
 //! the PTY or `app-tauri` (that is P6b). It is fully testable with in-memory fakes
 //! of the three ports.
 
+mod paginate;
 mod record;
+mod rotate;
 
+pub use paginate::{
+    ConversationArchiveProvider, ReadConversationPage, ReadConversationPageInput, TurnPage,
+    TurnSource, TurnView,
+};
 pub use record::RecordTurn;
+pub use rotate::{RotateConversationLog, RotateConversationLogInput};

crates/application/src/conversation/paginate.rs

@@ -0,0 +1,148 @@
+//! [`ReadConversationPage`] — lecture **humaine** paginée d'une conversation (lot LS6).
+//!
+//! Lecture archive-aware (segments d'archive + actif) exposée comme un **DTO humain
+//! riche** : contrairement au handoff (résumé borné) ou au read-model work-state
+//! (aperçus tronqués), la page humaine porte le **texte complet, non borné** de chaque
+//! tour — c'est la vue « transcript » destinée à l'utilisateur (le React arrive en LS7).
+//!
+//! Hors chemin chaud : composé du seul port [`ConversationArchive`] (via un provider par
+//! root), jamais d'`append`/de rotation ici.
+
+use std::sync::Arc;
+
+use domain::project::ProjectPath;
+use domain::{AgentId, ConversationArchive, ConversationId, PageCursor, TurnId, TurnRole};
+
+use crate::error::AppError;
+
+/// Fournit le [`ConversationArchive`] **lié au project root** courant (lot LS6),
+/// calqué sur [`crate::HandoffProvider`]/[`crate::RecordTurnProvider`].
+///
+/// Les use cases d'archivage/pagination ([`crate::RotateConversationLog`],
+/// [`ReadConversationPage`]) sont **uniques** pour tous les projets, alors que les logs
+/// sont **par project root** (`<root>/.ideai/conversations/`) et l'adapter `Fs*` fixe sa
+/// racine à la construction. Ce port matérialise un archive ciblant le **bon** dossier à
+/// chaque appel. `None` ⇒ pas d'archivage/pagination (best-effort absent). Implémenté
+/// dans `app-tauri` (seul détenteur des adapters `Fs*`).
+pub trait ConversationArchiveProvider: Send + Sync {
+    /// Construit le [`ConversationArchive`] dont la persistance cible `root`, ou `None`.
+    fn conversation_archive_for(&self, root: &ProjectPath) -> Option<Arc<dyn ConversationArchive>>;
+}
+
+/// Origine d'un tour, pour la vue humaine paginée (miroir de [`domain::input::InputSource`]).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TurnSource {
+    /// L'opérateur humain.
+    Human,
+    /// Un autre agent (délégation via `idea_ask_agent`).
+    Agent {
+        /// L'agent à l'origine du tour.
+        agent_id: AgentId,
+    },
+}
+
+impl From<domain::input::InputSource> for TurnSource {
+    fn from(source: domain::input::InputSource) -> Self {
+        match source {
+            domain::input::InputSource::Human => Self::Human,
+            domain::input::InputSource::Agent { agent_id } => Self::Agent { agent_id },
+        }
+    }
+}
+
+/// Un tour projeté pour la vue humaine (lot LS6) — **texte complet, non borné**.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TurnView {
+    /// Identifiant stable du tour (sert aussi d'ancre de pagination).
+    pub id: TurnId,
+    /// Horodatage (epoch millisecondes).
+    pub at_ms: u64,
+    /// Nature du tour (invite, réponse, activité outillée).
+    pub role: TurnRole,
+    /// Origine (humain ou agent délégant).
+    pub source: TurnSource,
+    /// Le **texte intégral** du tour (jamais tronqué — c'est la vue transcript).
+    pub text: String,
+    /// Longueur (en caractères) du texte, pour l'UI.
+    pub text_len: usize,
+}
+
+impl From<domain::ConversationTurn> for TurnView {
+    fn from(turn: domain::ConversationTurn) -> Self {
+        let text_len = turn.text.chars().count();
+        Self {
+            id: turn.id,
+            at_ms: turn.at_ms,
+            role: turn.role,
+            source: turn.source.into(),
+            text: turn.text,
+            text_len,
+        }
+    }
+}
+
+/// Une page de tours pour la vue humaine (lot LS6).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TurnPage {
+    /// Les tours de la page, **du plus ancien au plus récent**.
+    pub turns: Vec<TurnView>,
+    /// `true` s'il existe d'autres tours au-delà de la page dans le sens de progression.
+    pub has_more: bool,
+    /// L'id du **dernier** tour de la page (ancre pour la requête suivante) ; `None` si
+    /// la page est vide.
+    pub next_anchor: Option<TurnId>,
+}
+
+/// Entrée de [`ReadConversationPage::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ReadConversationPageInput {
+    /// Le project root dont dériver l'archive.
+    pub project_root: ProjectPath,
+    /// La conversation (paire) à lire.
+    pub conversation: ConversationId,
+    /// Le curseur (ancre + sens) de pagination.
+    pub cursor: PageCursor,
+    /// La taille de page demandée (`0` ⇒ défaut ; clampée par le domaine).
+    pub limit: usize,
+}
+
+/// Use case de lecture humaine paginée (lot LS6) — consomme le seul
+/// [`ConversationArchive`] (résolu par root via le provider).
+pub struct ReadConversationPage {
+    archives: Arc<dyn ConversationArchiveProvider>,
+}
+
+impl ReadConversationPage {
+    /// Construit le use case à partir du provider d'archive par root.
+    #[must_use]
+    pub fn new(archives: Arc<dyn ConversationArchiveProvider>) -> Self {
+        Self { archives }
+    }
+
+    /// Lit une page de `conversation`, mappée vers le DTO humain riche.
+    ///
+    /// Provider d'archive absent pour ce root ⇒ page **vide** (best-effort, jamais une
+    /// erreur dure). Le texte de chaque tour est renvoyé **intégralement**.
+    ///
+    /// # Errors
+    /// [`AppError::Store`] si la lecture du log échoue.
+    pub async fn execute(&self, input: ReadConversationPageInput) -> Result<TurnPage, AppError> {
+        let Some(archive) = self.archives.conversation_archive_for(&input.project_root) else {
+            return Ok(TurnPage {
+                turns: Vec::new(),
+                has_more: false,
+                next_anchor: None,
+            });
+        };
+        let slice = archive
+            .page(input.conversation, input.cursor, input.limit)
+            .await?;
+        let next_anchor = slice.turns.last().map(|t| t.id);
+        let turns = slice.turns.into_iter().map(TurnView::from).collect();
+        Ok(TurnPage {
+            turns,
+            has_more: slice.has_more,
+            next_anchor,
+        })
+    }
+}

crates/application/src/conversation/record.rs

@@ -2,7 +2,10 @@
 
 use std::sync::Arc;
 
-use domain::{ConversationId, ConversationLog, ConversationTurn, HandoffStore, HandoffSummarizer};
+use domain::{
+    bound_handoff_summary, ConversationId, ConversationLog, ConversationTurn, HandoffStore,
+    HandoffSummarizer, HANDOFF_SUMMARY_MAX_CHARS,
+};
 
 use crate::error::AppError;
 
@@ -63,6 +66,9 @@ impl RecordTurn {
     /// 1. **append** the turn to the canonical log (source of truth) ;
     /// 2. **load** the previous handoff (`None` on a first checkpoint) ;
     /// 3. **fold** `prev` with the single new turn (incremental, best-effort) ;
+    /// 3b. **bound** the folded handoff's summary to [`HANDOFF_SUMMARY_MAX_CHARS`] — a
+    ///     **universal cap independent of the summarizer** (heuristic *or* a future LLM):
+    ///     idempotent, never rejecting, so it never blocks the checkpoint (LS5) ;
     /// 4. **save** the advanced handoff.
     ///
     /// The append happens **first** so the durable source of truth is never behind
@@ -92,6 +98,13 @@ impl RecordTurn {
             .fold(prev, std::slice::from_ref(&turn))
             .await;
 
+        // 3b. **Universal bound** (LS5): clamp the resume summary to
+        //     `HANDOFF_SUMMARY_MAX_CHARS`, *independently of the summarizer*. Whatever
+        //     produced the handoff — the heuristic or a future LLM summarizer — the
+        //     persisted (and later injected) summary is size-bounded. Idempotent and
+        //     never rejecting, so it can never block the checkpoint.
+        let handoff = bound_handoff_summary(handoff, HANDOFF_SUMMARY_MAX_CHARS);
+
         // 4. Persist the advanced handoff (overwrites the previous resume point).
         self.handoffs.save(conversation, handoff).await?;
 

crates/application/src/conversation/rotate.rs

@@ -0,0 +1,95 @@
+//! [`RotateConversationLog`] — rotation **best-effort** du log d'une conversation (lot LS6).
+//!
+//! Déclenchée **hors chemin chaud** (à la reprise/ouverture d'un fil, jamais par un
+//! `append`), elle borne le segment actif en archivant sa tête froide. L'invariant pivot
+//! (INV-LS6) est garanti par le **plancher** : `keep_from = up_to` du handoff courant ⇒
+//! aucun tour `≥ up_to` n'est jamais archivé, donc `read(since = up_to)` (fold incrémental)
+//! et la reprise restent corrects.
+//!
+//! Best-effort strict : pas de handoff (ou `up_to` nil) ⇒ skip ; toute erreur store est
+//! typée et **avalée par l'appelant** (le câblage app-tauri), jamais propagée en échec de
+//! reprise.
+
+use std::sync::Arc;
+
+use domain::project::ProjectPath;
+use domain::{rotation_plan, ConversationId, RotationDecision, RotationThresholds};
+
+use crate::conversation::ConversationArchiveProvider;
+use crate::error::AppError;
+use crate::HandoffProvider;
+
+/// Entrée de [`RotateConversationLog::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RotateConversationLogInput {
+    /// Le project root dont dériver l'archive et le handoff.
+    pub project_root: ProjectPath,
+    /// La conversation (paire) à roter.
+    pub conversation: ConversationId,
+}
+
+/// Use case de rotation du log (lot LS6) — consomme un [`ConversationArchive`] et le
+/// [`HandoffStore`] (pour lire `floor = up_to`), tous deux résolus par root.
+///
+/// [`ConversationArchive`]: domain::ConversationArchive
+/// [`HandoffStore`]: domain::HandoffStore
+pub struct RotateConversationLog {
+    archives: Arc<dyn ConversationArchiveProvider>,
+    handoffs: Arc<dyn HandoffProvider>,
+    thresholds: RotationThresholds,
+}
+
+impl RotateConversationLog {
+    /// Construit le use case à partir des providers par root (seuils par défaut).
+    #[must_use]
+    pub fn new(
+        archives: Arc<dyn ConversationArchiveProvider>,
+        handoffs: Arc<dyn HandoffProvider>,
+    ) -> Self {
+        Self {
+            archives,
+            handoffs,
+            thresholds: RotationThresholds::defaults(),
+        }
+    }
+
+    /// Applique la politique de rotation à `conversation`, si nécessaire.
+    ///
+    /// Étapes : résoudre l'archive + le handoff store du root ; lire le plancher
+    /// `floor = up_to` (pas de handoff ⇒ `None` ⇒ skip) ; lire les `stats` bon marché du
+    /// segment actif ; décider via [`rotation_plan`] ; archiver
+    /// (`rotate(keep_from = up_to)`) seulement si la décision est `Archive`.
+    ///
+    /// # Errors
+    /// [`AppError::Store`] si la lecture du handoff/stats ou la rotation échoue. L'appelant
+    /// (câblage) **avale** cette erreur : la rotation ne doit jamais casser une reprise.
+    pub async fn execute(&self, input: RotateConversationLogInput) -> Result<(), AppError> {
+        // Sans provider d'archive/handoff câblé pour ce root ⇒ rien à faire (best-effort).
+        let Some(archive) = self.archives.conversation_archive_for(&input.project_root) else {
+            return Ok(());
+        };
+        let Some(handoff_store) = self.handoffs.handoff_store_for(&input.project_root) else {
+            return Ok(());
+        };
+
+        // Plancher = `up_to` du handoff courant (pas de handoff ⇒ None ⇒ skip plus bas).
+        let floor = handoff_store
+            .load(input.conversation)
+            .await?
+            .map(|handoff| handoff.up_to);
+
+        let stats = archive.stats(input.conversation).await?;
+        match rotation_plan(
+            stats.active_turns,
+            stats.active_bytes,
+            floor,
+            self.thresholds,
+        ) {
+            RotationDecision::Skip => Ok(()),
+            RotationDecision::Archive { keep_from } => archive
+                .rotate(input.conversation, keep_from)
+                .await
+                .map_err(AppError::from),
+        }
+    }
+}

crates/application/src/diag.rs

@@ -0,0 +1,74 @@
+//! Lightweight, dependency-free diagnostics sink for the orchestrator rendezvous.
+//!
+//! The orchestrator already emits best-effort traces through `eprintln!` (see
+//! [`crate::orchestrator`]). When IdeA is launched by **clicking the AppImage**,
+//! that stderr is discarded — so an inter-agent block (an `ask` that never gets
+//! its `idea_reply`) leaves no retrievable trace. This module mirrors those
+//! traces to a **persistent log file** the user can hand back for diagnosis,
+//! while keeping the exact same "zero new dependency, never breaks the
+//! rendezvous" discipline: every write is best-effort and infallible.
+//!
+//! - [`set_log_path`] is called once by the composition root (`app-tauri`) with
+//!   `<app-data>/logs/idea.log`. Until then (and in tests) writes go to stderr
+//!   only.
+//! - [`diag`] (and the [`diag!`] macro) timestamps a line with epoch-millis — the
+//!   same clock as the conversation logs' `atMs` — and appends it to the file,
+//!   always also echoing to stderr so a terminal launch and the test suite still
+//!   see it.
+
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::{Mutex, OnceLock};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+/// The resolved log file path, set once at startup. `None` ⇒ stderr-only.
+static LOG_PATH: OnceLock<PathBuf> = OnceLock::new();
+
+/// Serialises concurrent appends so interleaved rendezvous beacons stay on their
+/// own lines (the orchestrator handles many connections in parallel).
+static WRITE_LOCK: Mutex<()> = Mutex::new(());
+
+/// Points the diagnostics sink at `path`, creating its parent directory.
+///
+/// Idempotent and infallible: a second call (or a failure to create the
+/// directory) is ignored — diagnostics must never break startup. Called by the
+/// composition root once the app-data directory is known.
+pub fn set_log_path(path: PathBuf) {
+    if let Some(parent) = path.parent() {
+        let _ = std::fs::create_dir_all(parent);
+    }
+    let _ = LOG_PATH.set(path);
+}
+
+/// Current epoch-millis (same clock as the conversation logs' `atMs`).
+fn now_ms() -> u128 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis())
+        .unwrap_or(0)
+}
+
+/// Appends one timestamped diagnostic line. Best-effort and infallible: a missing
+/// path or an I/O error is swallowed (the line still reaches stderr). Never call
+/// in a hot loop — these are lifecycle beacons, not a metrics stream.
+pub fn diag(msg: impl std::fmt::Display) {
+    let line = format!("{} {msg}", now_ms());
+    // Always echo to stderr: keeps a terminal launch and the test suite working,
+    // and preserves the pre-existing `eprintln!` behaviour for these beacons.
+    eprintln!("{line}");
+    if let Some(path) = LOG_PATH.get() {
+        let _guard = WRITE_LOCK.lock();
+        if let Ok(mut f) = OpenOptions::new().create(true).append(true).open(path) {
+            let _ = writeln!(f, "{line}");
+        }
+    }
+}
+
+/// `diag!("...", ...)` — formats then forwards to [`diag`]. Mirrors `eprintln!`.
+#[macro_export]
+macro_rules! diag {
+    ($($arg:tt)*) => {
+        $crate::diag::diag(format!($($arg)*))
+    };
+}

crates/application/src/error.rs

@@ -57,6 +57,33 @@ pub enum AppError {
         node_id: NodeId,
     },
 
+    /// The delegation target finished its turn and **returned to its prompt without
+    /// calling `idea_reply`**, so the rendezvous could produce no answer. Surfaced
+    /// promptly (after a short grace window) instead of blocking the caller until the
+    /// long safety timeout. **Retryable**: the caller may re-ask, ideally reminding the
+    /// target to render its result via `idea_reply` (never plain text). Carries the
+    /// target's display name.
+    #[error(
+        "agent {0} returned to its prompt without calling idea_reply (no answer was \
+         rendered); retry the request and ensure the agent replies via idea_reply"
+    )]
+    TargetReturnedNoReply(String),
+
+    /// The delegation target is **still actively working** (its transcript kept
+    /// growing across liveness probes) but the rendezvous **absolute ceiling** was
+    /// reached, so the synchronous wait was abandoned. **Distinct** from
+    /// [`Self::TargetReturnedNoReply`]: the target is *not* silent, so a blind retry
+    /// would stack a second heavy turn on a target already mid-task. **Not** a mute
+    /// timeout — the caller should check the target's in-progress work/branch (it may
+    /// still finish and call `idea_reply`) before re-soliciting lightly. Carries the
+    /// target's display name.
+    #[error(
+        "target {0} is still actively working but the rendezvous ceiling was reached; \
+         do not retry blindly — check the target's in-progress work/branch (it may still \
+         finish and call idea_reply), then re-solicit lightly if needed"
+    )]
+    TargetCeilingActive(String),
+
     /// An unexpected internal error.
     #[error("internal error: {0}")]
     Internal(String),
@@ -76,6 +103,8 @@ impl AppError {
             Self::Git(_) => "GIT",
             Self::Remote(_) => "REMOTE",
             Self::AgentAlreadyRunning { .. } => "AGENT_ALREADY_RUNNING",
+            Self::TargetReturnedNoReply(_) => "TARGET_RETURNED_NO_REPLY",
+            Self::TargetCeilingActive(_) => "RENDEZVOUS_CEILING_ACTIVE",
             Self::Internal(_) => "INTERNAL",
         }
     }
@@ -160,3 +189,31 @@ impl From<AgentSessionError> for AppError {
         Self::Process(e.to_string())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// La cible-active-au-plafond porte un code **stable et distinct** du no-reply
+    /// (l'appelant peut brancher sans parser le message) et un message « ne retente
+    /// pas à l'aveugle » différent du retour-au-prompt-sans-reply.
+    #[test]
+    fn ceiling_active_code_is_stable_and_distinct() {
+        let ceiling = AppError::TargetCeilingActive("architect".to_owned());
+        assert_eq!(ceiling.code(), "RENDEZVOUS_CEILING_ACTIVE");
+
+        let no_reply = AppError::TargetReturnedNoReply("architect".to_owned());
+        assert_eq!(no_reply.code(), "TARGET_RETURNED_NO_REPLY");
+
+        // Deux issues TYPÉES distinctes (le cœur du cadrage Architect) : un plafond
+        // atteint sur cible active n'est jamais confondu avec un silence/no-reply.
+        assert_ne!(ceiling.code(), no_reply.code());
+        // Et distinct d'un timeout muet (`Process` via AgentSessionError::Timeout).
+        assert_ne!(
+            ceiling.code(),
+            AppError::from(AgentSessionError::Timeout).code()
+        );
+        // Le message guide explicitement vers « ne pas retenter à l'aveugle ».
+        assert!(ceiling.to_string().contains("do not retry blindly"));
+    }
+}

crates/application/src/lib.rs

@@ -13,6 +13,7 @@
 
 pub mod agent;
 pub mod conversation;
+pub mod diag;
 pub mod embedder;
 pub mod error;
 pub mod git;
@@ -27,24 +28,30 @@ pub mod skill;
 pub mod template;
 pub mod terminal;
 pub mod window;
+pub mod workstate;
 
 pub use agent::{
-    drain_with_readiness, reference_profile_id, reference_profiles, selectable_reference_profiles,
-    send_blocking, ChangeAgentProfile, ChangeAgentProfileInput, ChangeAgentProfileOutput,
-    ConfigureProfiles, ConfigureProfilesInput, ConfigureProfilesOutput, CreateAgentFromScratch,
-    CreateAgentInput, CreateAgentOutput, DeleteAgent, DeleteAgentInput, DeleteProfile,
-    DeleteProfileInput, DetectProfiles, DetectProfilesInput, DetectProfilesOutput, FirstRunState,
-    FirstRunStateOutput, HandoffProvider, InspectConversation, InspectConversationInput,
-    InspectConversationOutput, LaunchAgent, LaunchAgentInput, LaunchAgentOutput, ListAgents,
-    ListAgentsInput, ListAgentsOutput, ListProfiles, ListProfilesOutput, ListResumableAgents,
-    ListResumableAgentsInput, ListResumableAgentsOutput, McpRuntime, PermissionProjectorRegistry,
-    ProfileAvailability,
-    ProviderSessionProvider, ReadAgentContext, ReadAgentContextInput, ReadAgentContextOutput,
-    ReferenceProfiles, ReferenceProfilesOutput, ResumableAgent, SaveProfile, SaveProfileInput,
-    SaveProfileOutput, StructuredSessionDescriptor, UpdateAgentContext, UpdateAgentContextInput,
-    AGENT_MEMORY_RECALL_BUDGET,
+    drain_with_readiness, drain_with_readiness_outcome,
+    reference_profile_id, reference_profiles,
+    selectable_reference_profiles, send_blocking, AgentResumer, ChangeAgentProfile,
+    ChangeAgentProfileInput, ChangeAgentProfileOutput, ConfigureProfiles, ConfigureProfilesInput,
+    ConfigureProfilesOutput, CreateAgentFromScratch, CreateAgentInput, CreateAgentOutput,
+    DeleteAgent, DeleteAgentInput, DeleteProfile, DeleteProfileInput, DetectProfiles,
+    DetectProfilesInput, DetectProfilesOutput, FirstRunState, FirstRunStateOutput, HandoffProvider,
+    InjectedLiveRow, InspectConversation, InspectConversationInput, InspectConversationOutput,
+    LaunchAgent, LaunchAgentInput, LaunchAgentOutput, ListAgents, ListAgentsInput,
+    ListAgentsOutput, ListProfiles, ListProfilesOutput, ListResumableAgents,
+    ListResumableAgentsInput, ListResumableAgentsOutput, LiveStateLeanProvider, McpRuntime,
+    PermissionProjectorRegistry, ProfileAvailability, ProviderSessionProvider, ReadAgentContext,
+    ReadAgentContextInput, ReadAgentContextOutput, ReferenceProfiles, ReferenceProfilesOutput,
+    ResumableAgent, SaveProfile, SaveProfileInput, SaveProfileOutput, SessionLimitService,
+    StructuredSessionDescriptor, TurnOutcome, UpdateAgentContext, UpdateAgentContextInput,
+    AGENT_MEMORY_RECALL_BUDGET, CODEX_SUBMIT_DELAY_MS, LIVE_STATE_INJECT_MAX, RESUME_PROMPT,
+};
+pub use conversation::{
+    ConversationArchiveProvider, ReadConversationPage, ReadConversationPageInput, RecordTurn,
+    RotateConversationLog, RotateConversationLogInput, TurnPage, TurnSource, TurnView,
 };
-pub use conversation::RecordTurn;
 pub use embedder::{
     CheckEmbedderSuggestion, CheckEmbedderSuggestionInput, CheckEmbedderSuggestionOutput,
     DeleteEmbedderProfile, DeleteEmbedderProfileInput, DescribeEmbedderEngines, DismissChoice,
@@ -71,13 +78,18 @@ pub use layout::{
 };
 pub use memory::{
     CreateMemory, CreateMemoryInput, CreateMemoryOutput, DeleteMemory, DeleteMemoryInput,
-    GetMemory, GetMemoryInput, GetMemoryOutput, ListMemories, ListMemoriesInput,
-    ListMemoriesOutput, ReadMemoryIndex, ReadMemoryIndexInput, ReadMemoryIndexOutput, RecallMemory,
-    RecallMemoryInput, RecallMemoryOutput, ResolveMemoryLinks, ResolveMemoryLinksInput,
-    ResolveMemoryLinksOutput, UpdateMemory, UpdateMemoryInput, UpdateMemoryOutput,
+    GetMemory, GetMemoryInput, GetMemoryOutput, HarvestMemoryFromTurn, ListMemories,
+    ListMemoriesInput, ListMemoriesOutput, MemoryHarvestOutcome, ReadMemoryIndex,
+    ReadMemoryIndexInput, ReadMemoryIndexOutput, RecallMemory, RecallMemoryInput,
+    RecallMemoryOutput, ResolveMemoryLinks, ResolveMemoryLinksInput, ResolveMemoryLinksOutput,
+    UpdateMemory, UpdateMemoryInput, UpdateMemoryOutput,
 };
 pub use orchestrator::{
-    McpRuntimeProvider, OrchestratorOutcome, OrchestratorService, RecordTurnProvider,
+    resolve_rendezvous_ceiling, resolve_rendezvous_window, run_inactivity_watchdog,
+    AskLivenessProbe, ContextGuardUseCases, LiveStateProvider, LiveStateReadProvider,
+    McpRuntimeProvider, OrchestratorOutcome, OrchestratorService, ProposeContext, ReadContext,
+    ReadMemory, RecordTurnProvider, WatchdogOutcome, WriteMemory, DEFAULT_RENDEZVOUS_CEILING,
+    DEFAULT_RENDEZVOUS_WINDOW,
 };
 pub use permission::{
     GetProjectPermissions, GetProjectPermissionsInput, GetProjectPermissionsOutput,
@@ -95,9 +107,9 @@ pub use project::{
 pub use remote::{ConnectRemote, ConnectRemoteInput, ConnectRemoteOutput};
 pub use skill::{
     AssignSkillToAgent, AssignSkillToAgentInput, CreateSkill, CreateSkillInput, CreateSkillOutput,
-    DeleteSkill, DeleteSkillInput, ListSkills, ListSkillsInput, ListSkillsOutput,
-    UnassignSkillFromAgent, UnassignSkillFromAgentInput, UpdateSkill, UpdateSkillInput,
-    UpdateSkillOutput,
+    DeleteSkill, DeleteSkillInput, ListSkills, ListSkillsInput, ListSkillsOutput, ReadSkill,
+    ReadSkillInput, UnassignSkillFromAgent, UnassignSkillFromAgentInput, UpdateSkill,
+    UpdateSkillInput, UpdateSkillOutput,
 };
 pub use template::{
     AgentDrift, CreateAgentFromTemplate, CreateAgentFromTemplateInput,
@@ -108,8 +120,18 @@ pub use template::{
     UpdateTemplateOutput,
 };
 pub use terminal::{
-    CloseTerminal, CloseTerminalInput, CloseTerminalOutput, LiveAgentRegistry, LiveSessions,
-    OpenTerminal, OpenTerminalInput, OpenTerminalOutput, ResizeTerminal, ResizeTerminalInput,
-    StructuredSessions, TerminalSessions, WriteToTerminal, WriteToTerminalInput,
+    CloseTerminal, CloseTerminalInput, CloseTerminalOutput, LiveAgentRegistry, LiveSessionKind,
+    LiveSessionSnapshot, LiveSessions, OpenTerminal, OpenTerminalInput, OpenTerminalOutput,
+    ResizeTerminal, ResizeTerminalInput, StructuredSessions, TerminalSessions, WriteToTerminal,
+    WriteToTerminalInput,
 };
 pub use window::{MoveTabToNewWindow, MoveTabToNewWindowInput, MoveTabToNewWindowOutput};
+pub use workstate::{
+    AgentTicketState, AgentWorkState, AttachLiveAgent, AttachLiveAgentInput, AttachLiveAgentOutput,
+    ConversationLogProvider, ConversationPreviewStatus, ConversationTurnWorkPreview,
+    ConversationWorkSummary, GetLiveStateLean, GetProjectWorkState, GetProjectWorkStateInput,
+    LeanLiveEntry, LeanLiveState, LiveWorkSession, ProjectWorkState, ReconcileLiveState,
+    ReconcileLiveStateInput, StopLiveAgent, StopLiveAgentInput, StopLiveAgentOutput,
+    TicketWorkSource, TicketWorkStatus, UpdateLiveState, UpdateLiveStateInput,
+    LIVE_STATE_MAX_ENTRIES, LIVE_STATE_TTL_MS,
+};

crates/application/src/memory/harvest.rs

@@ -0,0 +1,114 @@
+//! Auto-memory harvest use case (Lot E1).
+//!
+//! [`HarvestMemoryFromTurn`] turns the text of a finished agent turn into persisted
+//! memory notes when it embeds ` ```idea-memory ` directives (parsed by the pure
+//! [`domain::memory_harvest`] module). It is **best-effort strict**: it only acts on
+//! a `Response` turn, parses **only the current turn's text** (never the full log),
+//! and never fails — parse/store errors are collected into the returned
+//! [`MemoryHarvestOutcome`] so the orchestrator can drop them without ever turning a
+//! successful reply/ticket/handoff into an error.
+
+use std::sync::Arc;
+
+use domain::conversation_log::TurnRole;
+use domain::ports::{EventBus, MemoryStore};
+use domain::{
+    parse_memory_directives, DomainEvent, MarkdownDoc, Memory, MemoryFrontmatter,
+    MemoryHarvestDirective, MemorySlug, ProjectPath,
+};
+
+/// The outcome of harvesting one turn: a report the caller may log or ignore.
+///
+/// `found` is the number of `idea-memory` directives the agent emitted; `saved`
+/// the slugs successfully persisted; `skipped` how many were dropped (parse or
+/// store failures); `errors` the human-readable reasons (parse + store).
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct MemoryHarvestOutcome {
+    /// Number of `idea-memory` directives detected in the turn text.
+    pub found: usize,
+    /// Slugs of the notes that were saved (and announced).
+    pub saved: Vec<MemorySlug>,
+    /// Number of directives dropped (invalid, over-limit, or store failure).
+    pub skipped: usize,
+    /// One message per dropped directive (parse + persistence reasons).
+    pub errors: Vec<String>,
+}
+
+/// Validates and persists the memory directives embedded in a finished turn.
+///
+/// Talks only to ports ([`MemoryStore`], [`EventBus`]); announces
+/// [`DomainEvent::MemorySaved`] per saved note like the manual CRUD use cases.
+pub struct HarvestMemoryFromTurn {
+    memories: Arc<dyn MemoryStore>,
+    events: Arc<dyn EventBus>,
+}
+
+impl HarvestMemoryFromTurn {
+    /// Builds the use case from its ports.
+    #[must_use]
+    pub fn new(memories: Arc<dyn MemoryStore>, events: Arc<dyn EventBus>) -> Self {
+        Self { memories, events }
+    }
+
+    /// Harvests `text` (the current turn's content) into `root`'s memory store.
+    ///
+    /// Best-effort: returns a [`MemoryHarvestOutcome`] and **never** an error. A
+    /// non-`Response` turn is a no-op (empty outcome) — prompts and tool activity
+    /// never carry harvest directives.
+    pub async fn harvest(
+        &self,
+        root: &ProjectPath,
+        role: TurnRole,
+        text: &str,
+    ) -> MemoryHarvestOutcome {
+        if role != TurnRole::Response {
+            return MemoryHarvestOutcome::default();
+        }
+        let report = parse_memory_directives(text);
+        let mut outcome = MemoryHarvestOutcome {
+            found: report.found,
+            // Parse-level skips are already final; store-level skips are added below.
+            skipped: report.errors.len(),
+            errors: report.errors,
+            saved: Vec::new(),
+        };
+        for directive in report.directives {
+            match self.persist(root, directive).await {
+                Ok(slug) => outcome.saved.push(slug),
+                Err(err) => {
+                    outcome.skipped += 1;
+                    outcome.errors.push(err);
+                }
+            }
+        }
+        outcome
+    }
+
+    /// Persists one validated directive and announces it, mapping the (today
+    /// title-less) [`Memory`] entity from the directive. Returns the saved slug or
+    /// a message on a build/store failure (never panics).
+    async fn persist(
+        &self,
+        root: &ProjectPath,
+        directive: MemoryHarvestDirective,
+    ) -> Result<MemorySlug, String> {
+        let slug = directive.slug.clone();
+        // The persisted `Memory` has no title field today; the directive's `title`
+        // is intentionally not stored separately (the index derives its title from
+        // the slug). See the Lot E1 report's écart note.
+        let frontmatter = MemoryFrontmatter {
+            name: slug.clone(),
+            description: directive.description,
+            r#type: directive.r#type,
+        };
+        let memory = Memory::new(frontmatter, MarkdownDoc::new(directive.body.as_str()))
+            .map_err(|e| format!("invalid memory {slug}: {e}"))?;
+        self.memories
+            .save(root, &memory)
+            .await
+            .map_err(|e| format!("store failed for {slug}: {e}"))?;
+        self.events
+            .publish(DomainEvent::MemorySaved { slug: slug.clone() });
+        Ok(slug)
+    }
+}

crates/application/src/memory/mod.rs

@@ -12,8 +12,11 @@
 //! [`UpdateMemory`], [`DeleteMemory`]) announce a [`domain::DomainEvent`]; the
 //! read use cases emit nothing.
 
+mod harvest;
 mod usecases;
 
+pub use harvest::{HarvestMemoryFromTurn, MemoryHarvestOutcome};
+
 pub use usecases::{
     CreateMemory, CreateMemoryInput, CreateMemoryOutput, DeleteMemory, DeleteMemoryInput,
     GetMemory, GetMemoryInput, GetMemoryOutput, ListMemories, ListMemoriesInput,

crates/application/src/orchestrator/context_guard.rs

@@ -26,7 +26,7 @@
 use std::sync::Arc;
 
 use domain::conversation::ConversationParty;
-use domain::fileguard::{FileGuard, GuardError, GuardedResource};
+use domain::fileguard::{may_write_directly, FileGuard, GuardError, GuardedResource};
 use domain::markdown::MarkdownDoc;
 use domain::memory::{Memory, MemoryFrontmatter, MemorySlug, MemoryType};
 use domain::ports::{AgentContextStore, Clock, FileSystem, MemoryStore, RemotePath};
@@ -135,9 +135,10 @@ impl ReadContext {
 /// Proposes new content for an IdeA-owned context under the [`FileGuard`].
 ///
 /// For an **agent** context: a direct write under an exclusive write-lease. For the
-/// **global** project context by a non-orchestrator: the guard returns
-/// [`GuardError::Forbidden`], which this use case turns into a *materialised proposal*
-/// (a file under `.ideai/proposals/`) — never an overwrite of the live context.
+/// **global** project context by a non-orchestrator: the use case asks the domain
+/// policy whether the requester may write directly; otherwise it materialises a
+/// proposal (a file under `.ideai/proposals/`) — never an overwrite of the live
+/// context.
 pub struct ProposeContext {
     guard: Arc<dyn FileGuard>,
     contexts: Arc<dyn AgentContextStore>,
@@ -214,24 +215,23 @@ impl ProposeContext {
                 Ok(ProposeOutcome::Written)
             }
             None => {
-                // Global project context: single-writer. Try to acquire the write
-                // lease; Forbidden ⇒ materialise a proposal instead of overwriting.
-                match self
-                    .guard
-                    .acquire_write(requester, GuardedResource::ProjectContext)
-                    .await
-                {
-                    Ok(_lease) => {
-                        let path = join_root(&project, PROJECT_CONTEXT_FILE);
-                        self.fs.write(&path, content.as_bytes()).await?;
-                        Ok(ProposeOutcome::Written)
-                    }
-                    Err(GuardError::Forbidden) => {
-                        let path = self.file_proposal(&project, requester, &content).await?;
-                        Ok(ProposeOutcome::Proposed { path })
-                    }
-                    Err(other) => Err(map_guard_err(other)),
+                // Global project context: single-writer. Authorization stays in the
+                // domain policy; the guard only serialises the eventual direct write.
+                let manifest = self.contexts.load_manifest(&project).await?;
+                let designation = manifest.orchestrator_designation();
+                let resource = GuardedResource::ProjectContext;
+                if !may_write_directly(requester, &resource, &designation) {
+                    let path = self.file_proposal(&project, requester, &content).await?;
+                    return Ok(ProposeOutcome::Proposed { path });
                 }
+                let _lease = self
+                    .guard
+                    .acquire_write(requester, resource)
+                    .await
+                    .map_err(map_guard_err)?;
+                let path = join_root(&project, PROJECT_CONTEXT_FILE);
+                self.fs.write(&path, content.as_bytes()).await?;
+                Ok(ProposeOutcome::Written)
             }
         }
     }
@@ -392,7 +392,7 @@ mod tests {
     use async_trait::async_trait;
     use domain::agent::{AgentManifest, ManifestEntry};
     use domain::conversation::ConversationParty;
-    use domain::fileguard::{may_write_directly, ReadLease, WriteLease};
+    use domain::fileguard::{ReadLease, WriteLease};
     use domain::ports::{FsError, MemoryError, StoreError};
     use domain::project::ProjectPath;
     use domain::{ProfileId, ProjectId, RemoteRef};
@@ -443,12 +443,9 @@ mod tests {
         }
         async fn acquire_write(
             &self,
-            who: ConversationParty,
+            _who: ConversationParty,
             res: GuardedResource,
         ) -> Result<WriteLease, GuardError> {
-            if !may_write_directly(who, &res) {
-                return Err(GuardError::Forbidden);
-            }
             let lock = self.lock_for(&res);
             Ok(WriteLease::new(Box::new(lock.write_owned().await)))
         }
@@ -612,6 +609,7 @@ mod tests {
         Arc::new(FakeContexts {
             manifest: AgentManifest {
                 version: 1,
+                orchestrator: None,
                 entries: vec![ManifestEntry {
                     agent_id: agent,
                     name: name.to_owned(),

crates/application/src/orchestrator/mod.rs

@@ -5,12 +5,18 @@
 //! ever spawning a process itself. See [`service::OrchestratorService`].
 
 mod context_guard;
+pub mod rendezvous;
 mod service;
 
 pub use context_guard::{
     ProposeContext, ProposeContextInput, ProposeOutcome, ReadContext, ReadContextInput, ReadMemory,
     ReadMemoryInput, WriteMemory, WriteMemoryInput,
 };
+pub use rendezvous::{
+    resolve_rendezvous_ceiling, resolve_rendezvous_window, run_inactivity_watchdog,
+    WatchdogOutcome, DEFAULT_RENDEZVOUS_CEILING, DEFAULT_RENDEZVOUS_WINDOW,
+};
 pub use service::{
+    AskLivenessProbe, ContextGuardUseCases, LiveStateProvider, LiveStateReadProvider,
     McpRuntimeProvider, OrchestratorOutcome, OrchestratorService, RecordTurnProvider,
 };

crates/application/src/orchestrator/rendezvous.rs

@@ -0,0 +1,294 @@
+//! Inactivity watchdog for the synchronous inter-agent rendezvous
+//! (`idea_ask_agent` ⇄ `idea_reply`).
+//!
+//! # Why this exists (root cause)
+//!
+//! A delegation target can legitimately work for a **very long time in a single
+//! turn** (implement + `cargo test`/`clippy`), without ever returning to its prompt
+//! nor emitting an intermediate signal the application can race against: the AI CLI
+//! turn ([`domain::ports::AgentSession::send`]) only resolves **once the whole turn
+//! is done** — its `ReplyEvent`s arrive as one batch at the end, not incrementally.
+//! A **flat absolute timeout** around that wait therefore cuts a target that is
+//! manifestly alive (its transcript keeps growing) at the cap, surfacing a generic,
+//! non-actionable timeout.
+//!
+//! The fix is to bound the wait with an **inactivity window** re-armed on an observed
+//! **sign of life**, under an **absolute ceiling**, with **distinct typed outcomes**:
+//!
+//! - progress observed under the ceiling ⇒ re-arm the window (no timeout);
+//! - progress observed but the absolute ceiling is reached ⇒ a distinct
+//!   [`WatchdogOutcome::CeilingActive`] (the target is *active*, not silent — a blind
+//!   retry would stack a second heavy turn), never a mute timeout;
+//! - genuine silence (no progress across a whole window) ⇒
+//!   [`WatchdogOutcome::NoReply`], exactly the previous timeout semantics.
+//!
+//! # Sign of life
+//!
+//! Liveness cannot come from the event stream (it is batched at end-of-turn, see
+//! above), so it is supplied by an injected **monotonic activity probe** (in practice
+//! the cumulative byte size of the target's transcript, which grows mid-turn). The
+//! probe is a pure closure here — the algorithm stays free of infrastructure and is
+//! unit-testable with a synthetic future + probe.
+//!
+//! # DRY
+//!
+//! This is the **single** implementation of that algorithm. The application layer
+//! (`OrchestratorService`) governs the *delegated turn* with it (the seam that
+//! actually cuts a long turn), and the infrastructure MCP adapter re-uses the very
+//! same function as its outer safety net — no second, diverging copy.
+
+use std::future::Future;
+use std::time::{Duration, Instant};
+
+/// Verdict of [`run_inactivity_watchdog`] over an arbitrary `dispatch` future,
+/// decoupled from any concrete service/adapter so the algorithm is unit-testable
+/// with a synthetic future + probe.
+#[derive(Debug)]
+pub enum WatchdogOutcome<T> {
+    /// The dispatch resolved before the watchdog tripped — carries its value.
+    Resolved(T),
+    /// Genuine silence (no observable progress across a window), or the flat-window
+    /// fallback when no probe is wired ⇒ the **retryable** no-reply / timeout verdict.
+    NoReply,
+    /// The absolute ceiling was reached **while still observing progress** ⇒ the
+    /// distinct, **non-retryable-blind** "target active, ceiling reached" verdict.
+    CeilingActive,
+}
+
+/// Races `dispatch` against an inactivity `window`, re-arming the window each time the
+/// target shows **progress** (the monotonic token from `probe` strictly increased, or
+/// became observable for the first time) until the dispatch resolves or the absolute
+/// `ceiling` (measured from `started`) is reached.
+///
+/// - dispatch resolves first ⇒ [`WatchdogOutcome::Resolved`];
+/// - window elapses with **no progress** (token unchanged/regressed/lost, or
+///   `has_probe` is false ⇒ flat-window fallback) ⇒ [`WatchdogOutcome::NoReply`];
+/// - window elapses **with progress** but `started.elapsed() >= ceiling` ⇒
+///   [`WatchdogOutcome::CeilingActive`]; otherwise the window is re-armed.
+///
+/// `has_probe` distinguishes "no probe wired at all" (flat fallback: never progress,
+/// = the previous flat-timeout behaviour ⇒ zero regression) from "probe wired but
+/// currently returns `None`" (cannot prove liveness ⇒ treated as no progress).
+///
+/// `on_extended` / `on_expired` / `on_ceiling` are best-effort observation hooks
+/// (diagnostics beacons); pass no-ops to ignore them.
+#[allow(clippy::too_many_arguments)]
+pub async fn run_inactivity_watchdog<T, F, Fut>(
+    dispatch: impl Future<Output = T>,
+    window: Duration,
+    ceiling: Duration,
+    started: Instant,
+    has_probe: bool,
+    mut probe: F,
+    mut on_extended: impl FnMut(Duration),
+    mut on_expired: impl FnMut(Duration),
+    mut on_ceiling: impl FnMut(Duration),
+) -> WatchdogOutcome<T>
+where
+    F: FnMut() -> Fut,
+    Fut: Future<Output = Option<u64>>,
+{
+    tokio::pin!(dispatch);
+    // Baseline token before the first window; progress is judged relative to it.
+    let mut last_token = if has_probe { probe().await } else { None };
+    loop {
+        match tokio::time::timeout(window, &mut dispatch).await {
+            Ok(result) => return WatchdogOutcome::Resolved(result),
+            Err(_elapsed) => {
+                let elapsed = started.elapsed();
+                let now = if has_probe { probe().await } else { None };
+                // Progress iff a probe is wired AND the token strictly advanced (or
+                // became observable for the first time). No probe ⇒ never progress
+                // (flat-window fallback). Token lost ⇒ no proof of life ⇒ no progress.
+                let progressed = match (has_probe, last_token, now) {
+                    (false, _, _) => false,
+                    (true, Some(prev), Some(cur)) => cur > prev,
+                    (true, None, Some(_)) => true,
+                    (true, _, None) => false,
+                };
+                if progressed {
+                    if elapsed >= ceiling {
+                        on_ceiling(elapsed);
+                        return WatchdogOutcome::CeilingActive;
+                    }
+                    on_extended(elapsed);
+                    last_token = now;
+                    continue;
+                }
+                on_expired(elapsed);
+                return WatchdogOutcome::NoReply;
+            }
+        }
+    }
+}
+
+/// Default inactivity window (silence budget) of the inter-agent rendezvous: the size
+/// of **one** no-progress probe window, NOT an absolute cap. 600 s, matching the
+/// historical flat cap so a genuinely silent target still expires in the same delay.
+pub const DEFAULT_RENDEZVOUS_WINDOW: Duration = Duration::from_secs(600);
+
+/// Default absolute ceiling of the inter-agent rendezvous: the extending inactivity
+/// window never parks a call past this even against a perpetually-busy target.
+/// Generous (4 h) so a heavy-but-real single turn finishes well within it.
+pub const DEFAULT_RENDEZVOUS_CEILING: Duration = Duration::from_secs(4 * 60 * 60);
+
+/// Resolves the effective rendezvous **inactivity window** from an optional override in
+/// **milliseconds**: `Some(ms>0)` ⇒ that window, else the [`DEFAULT_RENDEZVOUS_WINDOW`].
+/// `Some(0)` is treated as "no override" so a misconfigured zero can never collapse the
+/// window to an instant expiry. Pure and unit-testable without wiring.
+#[must_use]
+pub fn resolve_rendezvous_window(override_ms: Option<u32>) -> Duration {
+    match override_ms {
+        Some(ms) if ms > 0 => Duration::from_millis(u64::from(ms)),
+        _ => DEFAULT_RENDEZVOUS_WINDOW,
+    }
+}
+
+/// Resolves the effective rendezvous **absolute ceiling** from an optional override in
+/// **milliseconds**: `Some(ms>0)` ⇒ that ceiling, else [`DEFAULT_RENDEZVOUS_CEILING`].
+/// `Some(0)` is treated as "no override". Pure and unit-testable without wiring.
+#[must_use]
+pub fn resolve_rendezvous_ceiling(override_ms: Option<u32>) -> Duration {
+    match override_ms {
+        Some(ms) if ms > 0 => Duration::from_millis(u64::from(ms)),
+        _ => DEFAULT_RENDEZVOUS_CEILING,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use std::sync::Arc;
+
+    /// A `dispatch` future that never resolves — stands in for a target busy in one
+    /// long turn (or wedged) that has not yet produced a reply.
+    async fn never() -> Result<u32, u32> {
+        std::future::pending::<()>().await;
+        unreachable!()
+    }
+
+    const WINDOW: Duration = Duration::from_millis(30);
+
+    fn noop(_: Duration) {}
+
+    /// (c) Vrai silence : un probe est câblé mais son token n'avance jamais ⇒ le
+    /// watchdog expire en ~une fenêtre avec le verdict no-reply (pas d'extension),
+    /// soit exactement l'ancien timeout plat.
+    #[tokio::test]
+    async fn silent_target_expires_no_reply() {
+        let started = Instant::now();
+        let probe = || async { Some(42_u64) };
+        let outcome = run_inactivity_watchdog(
+            never(),
+            WINDOW,
+            Duration::from_secs(3600),
+            started,
+            true,
+            probe,
+            noop,
+            noop,
+            noop,
+        )
+        .await;
+        assert!(matches!(outcome, WatchdogOutcome::NoReply));
+        assert!(started.elapsed() < Duration::from_secs(1));
+    }
+
+    /// (d) Non-régression du fallback fenêtre plate : sans probe câblé, la première
+    /// expiration de fenêtre est un no-reply (= ancien timeout plat).
+    #[tokio::test]
+    async fn no_probe_falls_back_to_flat_window() {
+        let started = Instant::now();
+        let probe = || async { None };
+        let outcome = run_inactivity_watchdog(
+            never(),
+            WINDOW,
+            Duration::from_secs(3600),
+            started,
+            false,
+            probe,
+            noop,
+            noop,
+            noop,
+        )
+        .await;
+        assert!(matches!(outcome, WatchdogOutcome::NoReply));
+    }
+
+    /// (a) Cible qui progresse AU-DELÀ de l'ancien plafond : le probe avance à chaque
+    /// tick (extension) bien au-delà d'une fenêtre, puis la dispatch se résout ⇒ AUCUN
+    /// timeout prématuré, le résultat est rendu. C'est le défaut central corrigé.
+    #[tokio::test]
+    async fn progressing_target_extends_then_resolves() {
+        let started = Instant::now();
+        let tick = Arc::new(AtomicU64::new(0));
+        let tick2 = Arc::clone(&tick);
+        let probe = move || {
+            let tick = Arc::clone(&tick2);
+            async move { Some(tick.fetch_add(1, Ordering::SeqCst) + 1) }
+        };
+        // Résout après ~plusieurs fenêtres (110 ms ≫ 30 ms) : sans réarmement, un
+        // timeout plat de 30 ms aurait coupé. Le watchdog doit étendre et rendre 7.
+        let dispatch = async {
+            tokio::time::sleep(Duration::from_millis(110)).await;
+            Ok::<u32, u32>(7)
+        };
+        let outcome = run_inactivity_watchdog(
+            dispatch,
+            WINDOW,
+            Duration::from_secs(3600),
+            started,
+            true,
+            probe,
+            noop,
+            noop,
+            noop,
+        )
+        .await;
+        match outcome {
+            WatchdogOutcome::Resolved(Ok(v)) => assert_eq!(v, 7),
+            _ => panic!("expected Resolved(Ok(7)) — la fenêtre aurait dû être réarmée"),
+        }
+    }
+
+    /// (b) Plafond absolu atteint malgré progrès : le probe avance toujours (cible
+    /// active) mais le plafond est minuscule ⇒ verdict DISTINCT CeilingActive (pas un
+    /// faux no-reply muet), et l'appel termine (jamais parqué à l'infini).
+    #[tokio::test]
+    async fn progressing_target_hits_ceiling_distinctly() {
+        let started = Instant::now();
+        let tick = Arc::new(AtomicU64::new(0));
+        let tick2 = Arc::clone(&tick);
+        let probe = move || {
+            let tick = Arc::clone(&tick2);
+            async move { Some(tick.fetch_add(1, Ordering::SeqCst) + 1) }
+        };
+        let outcome = run_inactivity_watchdog(
+            never(),
+            WINDOW,
+            Duration::from_millis(45),
+            started,
+            true,
+            probe,
+            noop,
+            noop,
+            noop,
+        )
+        .await;
+        assert!(matches!(outcome, WatchdogOutcome::CeilingActive));
+        assert!(started.elapsed() < Duration::from_secs(1));
+    }
+
+    /// Les résolveurs honorent un override et retombent sur leurs défauts finis ;
+    /// `Some(0)` ⇒ "pas d'override" (jamais d'effondrement instantané).
+    #[test]
+    fn resolvers_apply_override_else_finite_default() {
+        assert_eq!(resolve_rendezvous_window(Some(1234)), Duration::from_millis(1234));
+        assert_eq!(resolve_rendezvous_window(Some(0)), DEFAULT_RENDEZVOUS_WINDOW);
+        assert_eq!(resolve_rendezvous_window(None), DEFAULT_RENDEZVOUS_WINDOW);
+        assert_eq!(resolve_rendezvous_ceiling(Some(9999)), Duration::from_millis(9999));
+        assert_eq!(resolve_rendezvous_ceiling(Some(0)), DEFAULT_RENDEZVOUS_CEILING);
+        assert_eq!(resolve_rendezvous_ceiling(None), DEFAULT_RENDEZVOUS_CEILING);
+    }
+}

crates/application/src/skill/mod.rs

@@ -15,7 +15,7 @@ mod usecases;
 
 pub use usecases::{
     AssignSkillToAgent, AssignSkillToAgentInput, CreateSkill, CreateSkillInput, CreateSkillOutput,
-    DeleteSkill, DeleteSkillInput, ListSkills, ListSkillsInput, ListSkillsOutput,
-    UnassignSkillFromAgent, UnassignSkillFromAgentInput, UpdateSkill, UpdateSkillInput,
-    UpdateSkillOutput,
+    DeleteSkill, DeleteSkillInput, ListSkills, ListSkillsInput, ListSkillsOutput, ReadSkill,
+    ReadSkillInput, UnassignSkillFromAgent, UnassignSkillFromAgentInput, UpdateSkill,
+    UpdateSkillInput, UpdateSkillOutput,
 };

crates/application/src/skill/usecases.rs

@@ -25,6 +25,10 @@ use crate::error::AppError;
 pub struct CreateSkillInput {
     /// Display name (also the `.md` stem on disk).
     pub name: String,
+    /// Optional one-line affordance description (feature « skills à la MCP »).
+    /// `None`/empty ⇒ the skill falls back to the first line of its body when
+    /// surfaced (see [`domain::Skill::effective_description`]).
+    pub description: Option<String>,
     /// Initial Markdown body.
     pub content: String,
     /// Scope the skill is created in (selects its backing store).
@@ -61,7 +65,8 @@ impl CreateSkill {
     pub async fn execute(&self, input: CreateSkillInput) -> Result<CreateSkillOutput, AppError> {
         let id = SkillId::from_uuid(self.ids.new_uuid());
         let skill = Skill::new(id, input.name, MarkdownDoc::new(input.content), input.scope)
-            .map_err(|e| AppError::Invalid(e.to_string()))?;
+            .map_err(|e| AppError::Invalid(e.to_string()))?
+            .with_description(input.description);
         self.skills.save(&skill, &input.project_root).await?;
         Ok(CreateSkillOutput { skill })
     }
@@ -204,6 +209,77 @@ impl DeleteSkill {
     }
 }
 
+// ---------------------------------------------------------------------------
+// ReadSkill
+// ---------------------------------------------------------------------------
+
+/// Input for [`ReadSkill::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ReadSkillInput {
+    /// Skill display name to resolve (case-insensitive).
+    pub name: String,
+    /// Active project root (used for the [`SkillScope::Project`] lookup).
+    pub project_root: ProjectPath,
+}
+
+/// Reads a skill's Markdown body **by name** — the application side of the MCP
+/// `idea_skill_read` tool (feature « skills à la MCP »).
+///
+/// Resolution follows the affordance contract: **project scope first, then
+/// global** (a project skill shadows a global one of the same name). It composes
+/// the **existing** [`SkillStore`] port only — no new port. Read-only.
+pub struct ReadSkill {
+    skills: Arc<dyn SkillStore>,
+}
+
+impl ReadSkill {
+    /// Builds the use case from the existing skill store port.
+    #[must_use]
+    pub fn new(skills: Arc<dyn SkillStore>) -> Self {
+        Self { skills }
+    }
+
+    /// Resolves `name` in `scope`, returning the single match.
+    ///
+    /// `Ok(None)` ⇒ no skill by that name in this scope; `Err(Invalid)` ⇒ the
+    /// name is **ambiguous** (more than one skill shares it in this scope).
+    async fn resolve_in(
+        &self,
+        scope: SkillScope,
+        input: &ReadSkillInput,
+    ) -> Result<Option<Skill>, AppError> {
+        let all = self.skills.list(scope, &input.project_root).await?;
+        let mut matches = all
+            .into_iter()
+            .filter(|s| s.name.eq_ignore_ascii_case(&input.name));
+        match (matches.next(), matches.next()) {
+            (None, _) => Ok(None),
+            (Some(skill), None) => Ok(Some(skill)),
+            (Some(_), Some(_)) => Err(AppError::Invalid(format!(
+                "skill name `{}` is ambiguous in {scope:?} scope (several skills share it)",
+                input.name
+            ))),
+        }
+    }
+
+    /// Resolves the skill by name and returns its Markdown body.
+    ///
+    /// # Errors
+    /// - [`AppError::Invalid`] if the name is ambiguous within a scope,
+    /// - [`AppError::NotFound`] if no skill carries that name in either scope,
+    /// - [`AppError::Store`] on a store failure.
+    pub async fn execute(&self, input: ReadSkillInput) -> Result<MarkdownDoc, AppError> {
+        // Project scope shadows global: try it first, then fall back to global.
+        if let Some(skill) = self.resolve_in(SkillScope::Project, &input).await? {
+            return Ok(skill.content_md);
+        }
+        if let Some(skill) = self.resolve_in(SkillScope::Global, &input).await? {
+            return Ok(skill.content_md);
+        }
+        Err(AppError::NotFound(format!("skill `{}`", input.name)))
+    }
+}
+
 // ---------------------------------------------------------------------------
 // AssignSkillToAgent / UnassignSkillFromAgent
 // ---------------------------------------------------------------------------
@@ -349,3 +425,185 @@ impl UnassignSkillFromAgent {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+
+    use async_trait::async_trait;
+    use domain::ports::{SkillStore, StoreError};
+
+    /// In-memory [`SkillStore`] fake: skills are bucketed by scope, ignoring the
+    /// project root (the [`ReadSkill`] resolution logic is root-agnostic — it only
+    /// switches scope). Enough to exercise project-first resolution, shadowing,
+    /// ambiguity and absence without touching disk.
+    #[derive(Default)]
+    struct FakeSkillStore {
+        global: Mutex<Vec<Skill>>,
+        project: Mutex<Vec<Skill>>,
+    }
+
+    impl FakeSkillStore {
+        fn bucket(&self, scope: SkillScope) -> &Mutex<Vec<Skill>> {
+            match scope {
+                SkillScope::Global => &self.global,
+                SkillScope::Project => &self.project,
+            }
+        }
+
+        fn push(&self, skill: Skill) {
+            self.bucket(skill.scope).lock().unwrap().push(skill);
+        }
+    }
+
+    #[async_trait]
+    impl SkillStore for FakeSkillStore {
+        async fn list(
+            &self,
+            scope: SkillScope,
+            _root: &ProjectPath,
+        ) -> Result<Vec<Skill>, StoreError> {
+            Ok(self.bucket(scope).lock().unwrap().clone())
+        }
+        async fn get(
+            &self,
+            scope: SkillScope,
+            _root: &ProjectPath,
+            id: SkillId,
+        ) -> Result<Skill, StoreError> {
+            self.bucket(scope)
+                .lock()
+                .unwrap()
+                .iter()
+                .find(|s| s.id == id)
+                .cloned()
+                .ok_or(StoreError::NotFound)
+        }
+        async fn save(&self, skill: &Skill, _root: &ProjectPath) -> Result<(), StoreError> {
+            self.push(skill.clone());
+            Ok(())
+        }
+        async fn delete(
+            &self,
+            _scope: SkillScope,
+            _root: &ProjectPath,
+            _id: SkillId,
+        ) -> Result<(), StoreError> {
+            Ok(())
+        }
+    }
+
+    fn root() -> ProjectPath {
+        ProjectPath::new("/proj").unwrap()
+    }
+
+    fn skill(id: u128, name: &str, body: &str, scope: SkillScope) -> Skill {
+        Skill::new(
+            SkillId::from_uuid(uuid::Uuid::from_u128(id)),
+            name,
+            MarkdownDoc::new(body),
+            scope,
+        )
+        .unwrap()
+    }
+
+    fn read_skill_uc(store: Arc<FakeSkillStore>) -> ReadSkill {
+        ReadSkill::new(store)
+    }
+
+    #[tokio::test]
+    async fn read_skill_resolves_project_scope() {
+        // (a) skill present in the project scope ⇒ its body is returned.
+        let store = Arc::new(FakeSkillStore::default());
+        store.push(skill(1, "deploy", "PROJECT_BODY", SkillScope::Project));
+
+        let body = read_skill_uc(store)
+            .execute(ReadSkillInput {
+                name: "deploy".to_owned(),
+                project_root: root(),
+            })
+            .await
+            .unwrap();
+        assert_eq!(body.as_str(), "PROJECT_BODY");
+    }
+
+    #[tokio::test]
+    async fn read_skill_falls_back_to_global_scope() {
+        // (b) absent from project but present globally ⇒ resolved via global.
+        let store = Arc::new(FakeSkillStore::default());
+        store.push(skill(1, "deploy", "GLOBAL_BODY", SkillScope::Global));
+
+        let body = read_skill_uc(store)
+            .execute(ReadSkillInput {
+                name: "deploy".to_owned(),
+                project_root: root(),
+            })
+            .await
+            .unwrap();
+        assert_eq!(body.as_str(), "GLOBAL_BODY");
+    }
+
+    #[tokio::test]
+    async fn read_skill_project_shadows_global() {
+        // (c) same name in both scopes ⇒ project wins.
+        let store = Arc::new(FakeSkillStore::default());
+        store.push(skill(1, "deploy", "GLOBAL_BODY", SkillScope::Global));
+        store.push(skill(2, "deploy", "PROJECT_BODY", SkillScope::Project));
+
+        let body = read_skill_uc(store)
+            .execute(ReadSkillInput {
+                name: "deploy".to_owned(),
+                project_root: root(),
+            })
+            .await
+            .unwrap();
+        assert_eq!(body.as_str(), "PROJECT_BODY");
+    }
+
+    #[tokio::test]
+    async fn read_skill_is_case_insensitive() {
+        let store = Arc::new(FakeSkillStore::default());
+        store.push(skill(1, "Deploy", "BODY", SkillScope::Project));
+
+        let body = read_skill_uc(store)
+            .execute(ReadSkillInput {
+                name: "deploy".to_owned(),
+                project_root: root(),
+            })
+            .await
+            .unwrap();
+        assert_eq!(body.as_str(), "BODY");
+    }
+
+    #[tokio::test]
+    async fn read_skill_unknown_is_not_found() {
+        // (d) unknown in both scopes ⇒ NotFound.
+        let store = Arc::new(FakeSkillStore::default());
+        let err = read_skill_uc(store)
+            .execute(ReadSkillInput {
+                name: "ghost".to_owned(),
+                project_root: root(),
+            })
+            .await
+            .unwrap_err();
+        assert!(matches!(err, AppError::NotFound(_)), "got {err:?}");
+    }
+
+    #[tokio::test]
+    async fn read_skill_ambiguous_name_is_invalid() {
+        // (e) two skills share a name within a scope ⇒ Invalid (ambiguous).
+        let store = Arc::new(FakeSkillStore::default());
+        store.push(skill(1, "deploy", "ONE", SkillScope::Project));
+        store.push(skill(2, "Deploy", "TWO", SkillScope::Project));
+
+        let err = read_skill_uc(store)
+            .execute(ReadSkillInput {
+                name: "deploy".to_owned(),
+                project_root: root(),
+            })
+            .await
+            .unwrap_err();
+        assert!(matches!(err, AppError::Invalid(_)), "got {err:?}");
+    }
+}

crates/application/src/terminal/mod.rs

@@ -28,7 +28,10 @@
 mod registry;
 mod usecases;
 
-pub use registry::{LiveAgentRegistry, LiveSessions, StructuredSessions, TerminalSessions};
+pub use registry::{
+    LiveAgentRegistry, LiveSessionKind, LiveSessionSnapshot, LiveSessions, StructuredSessions,
+    TerminalSessions,
+};
 pub use usecases::{
     CloseTerminal, CloseTerminalInput, CloseTerminalOutput, OpenTerminal, OpenTerminalInput,
     OpenTerminalOutput, ResizeTerminal, ResizeTerminalInput, WriteToTerminal, WriteToTerminalInput,

crates/application/src/terminal/registry.rs

@@ -13,6 +13,28 @@ use domain::conversation::ConversationId;
 use domain::ports::{AgentSession, PtyHandle};
 use domain::{AgentId, NodeId, SessionId, SessionKind, TerminalSession};
 
+/// Runtime family of a live agent session.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LiveSessionKind {
+    /// Raw PTY-backed CLI session.
+    Pty,
+    /// Structured agent-session backend.
+    Structured,
+}
+
+/// Read-only coordinates of one live agent session.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct LiveSessionSnapshot {
+    /// The agent owning the live session.
+    pub agent_id: AgentId,
+    /// The layout node currently hosting the session view.
+    pub node_id: NodeId,
+    /// The live session id.
+    pub session_id: SessionId,
+    /// Which runtime registry owns the session.
+    pub kind: LiveSessionKind,
+}
+
 /// A registered, live terminal: its PTY handle plus the domain snapshot.
 #[derive(Debug, Clone)]
 struct Entry {
@@ -380,6 +402,22 @@ impl StructuredSessions {
         })
     }
 
+    /// Résout les coordonnées `(agent_id, node_id)` d'une session structurée par son
+    /// [`SessionId`] (LS7, tap niveau 1 des limites de session, §21.10).
+    ///
+    /// Jumeau « inverse » de [`Self::live_agents`] : là où `live_agents` énumère tout,
+    /// celui-ci fait un lookup direct par id. Le pump structuré (`agent_send`) n'a en
+    /// main que le `SessionId` du tour ; ce lookup lui rend l'agent et la cellule à
+    /// passer à [`SessionLimitService::on_rate_limited`](crate::SessionLimitService) sur
+    /// un signal `RateLimited`. `None` si l'id n'est pas (ou plus) une session vivante.
+    #[must_use]
+    pub fn meta_for_session(&self, id: &SessionId) -> Option<(AgentId, NodeId)> {
+        self.entries
+            .lock()
+            .ok()
+            .and_then(|m| m.get(id).map(|e| (e.agent_id, e.node_id)))
+    }
+
     /// Liste chaque agent IA vivant, sa cellule hôte et son id de session.
     ///
     /// Jumeau de [`TerminalSessions::live_agents`] : un tuple
@@ -500,6 +538,31 @@ impl LiveSessions {
         all.extend(self.structured.live_agents());
         all
     }
+
+    /// Tous les agents vivants avec le type de registre source (PTY puis structuré).
+    #[must_use]
+    pub fn live_agent_snapshots(&self) -> Vec<LiveSessionSnapshot> {
+        let mut all: Vec<LiveSessionSnapshot> = self
+            .pty
+            .live_agents()
+            .into_iter()
+            .map(|(agent_id, node_id, session_id)| LiveSessionSnapshot {
+                agent_id,
+                node_id,
+                session_id,
+                kind: LiveSessionKind::Pty,
+            })
+            .collect();
+        all.extend(self.structured.live_agents().into_iter().map(
+            |(agent_id, node_id, session_id)| LiveSessionSnapshot {
+                agent_id,
+                node_id,
+                session_id,
+                kind: LiveSessionKind::Structured,
+            },
+        ));
+        all
+    }
 }
 
 impl LiveAgentRegistry for LiveSessions {

crates/application/src/workstate/actions.rs

@@ -0,0 +1,177 @@
+//! Agent-level controlled actions over live sessions (Lot D).
+//!
+//! Companion to the read-only work-state model: these use cases let the UI drive
+//! an **already-running** agent's live session by **agent id**, never by spawning a
+//! new process. [`AttachLiveAgent`] rebinds the hosting cell ("a cell is a view");
+//! [`StopLiveAgent`] tears the live session down polymorphically (PTY kill vs
+//! structured shutdown). Neither touches the agent entity, its tickets, the
+//! conversation summaries, the handoff or the provider sessions.
+
+use std::sync::Arc;
+
+use domain::{AgentId, NodeId, Project, SessionId};
+
+use crate::error::AppError;
+use crate::terminal::{CloseTerminal, CloseTerminalInput, LiveSessionKind, LiveSessions};
+
+/// Input for [`AttachLiveAgent::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AttachLiveAgentInput {
+    /// The owning project (boundary/symmetry; the registries are global by agent).
+    pub project: Project,
+    /// The already-running agent whose live session is rebound.
+    pub agent_id: AgentId,
+    /// The layout leaf that should host the live session view.
+    pub node_id: NodeId,
+}
+
+/// Output of [`AttachLiveAgent::execute`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AttachLiveAgentOutput {
+    /// The rebound agent.
+    pub agent_id: AgentId,
+    /// The node now hosting the session view.
+    pub node_id: NodeId,
+    /// The unchanged live session id.
+    pub session_id: SessionId,
+    /// Runtime family that owns the session.
+    pub kind: LiveSessionKind,
+}
+
+/// Rebinds an already-running agent session to a visible layout cell, never
+/// spawning a process ("a cell is a view").
+///
+/// Resolves the live session by agent in the PTY registry first, then the
+/// structured one, and updates only the hosting `node_id` (the PTY handle / agent
+/// session, its id and scrollback stay intact). Idempotent when the agent is
+/// already attached to the same node (the rebind is a no-op that returns the same
+/// session). No log/handoff/provider-session is touched.
+pub struct AttachLiveAgent {
+    live: Arc<LiveSessions>,
+}
+
+impl AttachLiveAgent {
+    /// Builds the use case from the aggregated live-session registry.
+    #[must_use]
+    pub fn new(live: Arc<LiveSessions>) -> Self {
+        Self { live }
+    }
+
+    /// Rebinds the agent's live session onto `node_id`.
+    ///
+    /// # Errors
+    /// [`AppError::NotFound`] when the agent has no live session in either registry.
+    pub fn execute(&self, input: AttachLiveAgentInput) -> Result<AttachLiveAgentOutput, AppError> {
+        // PTY first, then structured (one-live-session-per-agent ⇒ at most one match).
+        if let Some(session) = self
+            .live
+            .pty
+            .rebind_agent_node(&input.agent_id, input.node_id)
+        {
+            return Ok(AttachLiveAgentOutput {
+                agent_id: input.agent_id,
+                node_id: session.node_id,
+                session_id: session.id,
+                kind: LiveSessionKind::Pty,
+            });
+        }
+        if let Some(session) = self
+            .live
+            .structured
+            .rebind_agent_node(&input.agent_id, input.node_id)
+        {
+            return Ok(AttachLiveAgentOutput {
+                agent_id: input.agent_id,
+                node_id: input.node_id,
+                session_id: session.id(),
+                kind: LiveSessionKind::Structured,
+            });
+        }
+        Err(AppError::NotFound(format!(
+            "running session for agent {}",
+            input.agent_id
+        )))
+    }
+}
+
+/// Input for [`StopLiveAgent::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct StopLiveAgentInput {
+    /// The owning project (boundary/symmetry; the registries are global by agent).
+    pub project: Project,
+    /// The agent whose live session is stopped.
+    pub agent_id: AgentId,
+}
+
+/// Output of [`StopLiveAgent::execute`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct StopLiveAgentOutput {
+    /// The stopped agent.
+    pub agent_id: AgentId,
+    /// The id of the session that was torn down.
+    pub session_id: SessionId,
+    /// Runtime family that owned the session.
+    pub kind: LiveSessionKind,
+}
+
+/// Stops an already-running agent's live session, polymorphically.
+///
+/// Resolves the session by agent (PTY first, then structured). A PTY session is
+/// torn down through the existing [`CloseTerminal`] primitive (registry removal +
+/// process kill); a structured session is removed then `shutdown()`. The agent
+/// entity, its tickets, conversation summaries and handoff are **not** removed. Any
+/// exit event is left to the existing infrastructure (the PTY pump / session
+/// backend) — no bus is invented here.
+pub struct StopLiveAgent {
+    live: Arc<LiveSessions>,
+    close: Arc<CloseTerminal>,
+}
+
+impl StopLiveAgent {
+    /// Builds the use case from the live-session registry and the close primitive.
+    #[must_use]
+    pub fn new(live: Arc<LiveSessions>, close: Arc<CloseTerminal>) -> Self {
+        Self { live, close }
+    }
+
+    /// Tears down the agent's live session.
+    ///
+    /// # Errors
+    /// - [`AppError::NotFound`] when the agent has no live session,
+    /// - [`AppError::Process`] when the PTY kill or structured shutdown fails.
+    pub async fn execute(
+        &self,
+        input: StopLiveAgentInput,
+    ) -> Result<StopLiveAgentOutput, AppError> {
+        // PTY first: delegate to the existing close primitive (removes + kills).
+        if let Some(session_id) = self.live.pty.session_for_agent(&input.agent_id) {
+            self.close
+                .execute(CloseTerminalInput { session_id })
+                .await?;
+            return Ok(StopLiveAgentOutput {
+                agent_id: input.agent_id,
+                session_id,
+                kind: LiveSessionKind::Pty,
+            });
+        }
+        // Structured: remove from the registry first (so the uniqueness guard no
+        // longer sees a live session), then shut the session down out of the lock.
+        if let Some(session_id) = self.live.structured.session_id_for_agent(&input.agent_id) {
+            if let Some(session) = self.live.structured.remove(&session_id) {
+                session
+                    .shutdown()
+                    .await
+                    .map_err(|e| AppError::Process(e.to_string()))?;
+            }
+            return Ok(StopLiveAgentOutput {
+                agent_id: input.agent_id,
+                session_id,
+                kind: LiveSessionKind::Structured,
+            });
+        }
+        Err(AppError::NotFound(format!(
+            "running session for agent {}",
+            input.agent_id
+        )))
+    }
+}

crates/application/src/workstate/live.rs

@@ -0,0 +1,343 @@
+//! Live-state write/read use cases (programme live-state, lot LS2).
+//!
+//! The **live-state** is the durable-but-volatile "who is doing what right now"
+//! projection: one [`LiveEntry`] per agent, persisted through the
+//! [`LiveStateStore`] port (keyed last-writer-wins, never a journal).
+//!
+//! This module owns the two use cases over that port:
+//! - [`UpdateLiveState`] — publish/replace an agent's current row (write side),
+//!   stamping `updated_at_ms` from the injected [`Clock`] and enforcing the
+//!   domain field bounds via [`LiveEntry::new`].
+//! - [`GetLiveStateLean`] — prune-on-read then return a **distilled** snapshot
+//!   ([`LeanLiveState`]) for agent context injection and the future MCP tools.
+//!
+//! ## Boundary (programme invariant)
+//!
+//! The live-state stores **only what cannot be re-derived**: an agent's declared
+//! `intent`/`progress`, its current `ticket` and its `last_delegation`. Busy
+//! state, live sessions and the delegation queue are **computed elsewhere**
+//! ([`crate::workstate::GetProjectWorkState`]) and are deliberately *not* copied
+//! here. The lean DTO is also distinct from that rich, human-facing read model.
+
+use std::sync::Arc;
+
+use serde::{Deserialize, Serialize};
+
+use domain::live_state::{LiveEntry, LiveState, WorkStatus};
+use domain::ports::{Clock, LiveStateStore};
+use domain::{AgentId, TicketId};
+
+use crate::error::AppError;
+
+/// Default TTL for a live-state row, in milliseconds: **6 hours**.
+///
+/// An entry not refreshed within this window is considered stale and pruned on
+/// the next read. Six hours comfortably spans a normal working session (an agent
+/// that has not published anything for that long is effectively offline), while
+/// still bounding the file so a forgotten/abandoned project does not accumulate
+/// dead rows indefinitely.
+pub const LIVE_STATE_TTL_MS: u64 = 6 * 60 * 60 * 1_000;
+
+/// Default cardinality bound applied after the TTL sweep: keep at most this many
+/// most-recently-updated rows.
+///
+/// A project runs a handful of agents; `64` is a generous ceiling that still
+/// absorbs transient fan-out (an orchestrator delegating to many agents at once)
+/// while keeping the snapshot small and the injected context bounded.
+pub const LIVE_STATE_MAX_ENTRIES: usize = 64;
+
+/// Input for [`UpdateLiveState::execute`] — the elements of one live-state
+/// transition. `updated_at_ms` is **not** part of the input: it is stamped by the
+/// use case from the injected [`Clock`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UpdateLiveStateInput {
+    /// The agent publishing the transition (the keyed identity).
+    pub agent_id: AgentId,
+    /// The ticket it is currently handling, if any.
+    pub ticket: Option<TicketId>,
+    /// Short description of the current intent (domain-bounded on construction).
+    pub intent: String,
+    /// Coarse status at a glance.
+    pub status: WorkStatus,
+    /// Optional finer-grained progress note (domain-bounded on construction).
+    pub progress: Option<String>,
+    /// The ticket of the most recent delegation this agent issued, if any.
+    pub last_delegation: Option<TicketId>,
+}
+
+/// Publishes (inserts or replaces) an agent's live-state row.
+pub struct UpdateLiveState {
+    store: Arc<dyn LiveStateStore>,
+    clock: Arc<dyn Clock>,
+}
+
+impl UpdateLiveState {
+    /// Builds the use case from the injected store and clock ports.
+    #[must_use]
+    pub fn new(store: Arc<dyn LiveStateStore>, clock: Arc<dyn Clock>) -> Self {
+        Self { store, clock }
+    }
+
+    /// Stamps `updated_at_ms` from the clock, builds a validated [`LiveEntry`]
+    /// (applying the soft truncation / hard rejection bounds) and upserts it.
+    ///
+    /// # Errors
+    /// [`AppError::Invalid`] if a text field exceeds the domain hard threshold;
+    /// [`AppError::Store`] on a persistence failure.
+    pub async fn execute(&self, input: UpdateLiveStateInput) -> Result<(), AppError> {
+        let now_ms = u64::try_from(self.clock.now_millis()).unwrap_or(0);
+        let entry = LiveEntry::new(
+            input.agent_id,
+            input.ticket,
+            input.intent,
+            input.status,
+            input.progress,
+            input.last_delegation,
+            now_ms,
+        )
+        .map_err(|e| AppError::Invalid(e.to_string()))?;
+        self.store.upsert(entry).await?;
+        Ok(())
+    }
+}
+
+/// A single distilled live-state row for injection / MCP — the **lean** DTO,
+/// deliberately narrower than the rich human read model (no `progress` free-text,
+/// no timestamp). All free-text is already domain-bounded.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LeanLiveEntry {
+    /// The agent this row describes.
+    pub agent_id: AgentId,
+    /// Short description of what the agent is doing (domain-bounded).
+    pub intent: String,
+    /// Coarse status at a glance.
+    pub status: WorkStatus,
+    /// The ticket it is currently handling, if any.
+    pub ticket: Option<TicketId>,
+    /// The ticket of the most recent delegation it issued, if any.
+    pub last_delegation: Option<TicketId>,
+}
+
+impl From<LiveEntry> for LeanLiveEntry {
+    fn from(e: LiveEntry) -> Self {
+        Self {
+            agent_id: e.agent_id,
+            intent: e.intent,
+            status: e.status,
+            ticket: e.ticket,
+            last_delegation: e.last_delegation,
+        }
+    }
+}
+
+/// The distilled live-state snapshot returned by [`GetLiveStateLean`].
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LeanLiveState {
+    /// The current rows (already pruned), one per agent.
+    pub entries: Vec<LeanLiveEntry>,
+}
+
+impl From<LiveState> for LeanLiveState {
+    fn from(state: LiveState) -> Self {
+        Self {
+            entries: state.entries.into_iter().map(LeanLiveEntry::from).collect(),
+        }
+    }
+}
+
+/// Reads the live-state, pruning stale/excess rows first, and returns the lean
+/// snapshot.
+pub struct GetLiveStateLean {
+    store: Arc<dyn LiveStateStore>,
+    clock: Arc<dyn Clock>,
+}
+
+impl GetLiveStateLean {
+    /// Builds the use case from the injected store and clock ports.
+    #[must_use]
+    pub fn new(store: Arc<dyn LiveStateStore>, clock: Arc<dyn Clock>) -> Self {
+        Self { store, clock }
+    }
+
+    /// Applies the TTL + cardinality policy ([`LIVE_STATE_TTL_MS`],
+    /// [`LIVE_STATE_MAX_ENTRIES`]) at read time, then returns the distilled
+    /// snapshot.
+    ///
+    /// # Errors
+    /// [`AppError::Store`] on a persistence failure.
+    pub async fn execute(&self) -> Result<LeanLiveState, AppError> {
+        let now_ms = u64::try_from(self.clock.now_millis()).unwrap_or(0);
+        self.store
+            .prune(now_ms, LIVE_STATE_TTL_MS, LIVE_STATE_MAX_ENTRIES)
+            .await?;
+        let state = self.store.load().await?;
+        Ok(LeanLiveState::from(state))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::sync::Mutex;
+
+    use domain::live_state::FIELD_MAX_BYTES;
+    use domain::ports::StoreError;
+
+    /// In-memory [`LiveStateStore`] double mirroring the FS adapter's pure
+    /// semantics (keyed upsert + prune), with no I/O.
+    #[derive(Default)]
+    struct InMemoryLiveStateStore {
+        state: Mutex<LiveState>,
+    }
+
+    #[async_trait::async_trait]
+    impl LiveStateStore for InMemoryLiveStateStore {
+        async fn load(&self) -> Result<LiveState, StoreError> {
+            Ok(self.state.lock().unwrap().clone())
+        }
+        async fn upsert(&self, entry: LiveEntry) -> Result<(), StoreError> {
+            self.state.lock().unwrap().upsert(entry);
+            Ok(())
+        }
+        async fn prune(&self, now_ms: u64, ttl_ms: u64, max_n: usize) -> Result<(), StoreError> {
+            self.state.lock().unwrap().prune(now_ms, ttl_ms, max_n);
+            Ok(())
+        }
+    }
+
+    /// A fixed clock returning a preset epoch-ms value.
+    struct FixedClock(i64);
+    impl Clock for FixedClock {
+        fn now_millis(&self) -> i64 {
+            self.0
+        }
+    }
+
+    fn aid(n: u128) -> AgentId {
+        AgentId::from_uuid(uuid::Uuid::from_u128(n))
+    }
+
+    #[tokio::test]
+    async fn update_stamps_clock_and_persists() {
+        let store = Arc::new(InMemoryLiveStateStore::default());
+        let clock = Arc::new(FixedClock(4_242));
+        let uc = UpdateLiveState::new(store.clone(), clock);
+
+        uc.execute(UpdateLiveStateInput {
+            agent_id: aid(1),
+            ticket: None,
+            intent: "shipping".to_owned(),
+            status: WorkStatus::Working,
+            progress: None,
+            last_delegation: None,
+        })
+        .await
+        .unwrap();
+
+        let state = store.load().await.unwrap();
+        assert_eq!(state.entries.len(), 1);
+        assert_eq!(state.entries[0].intent, "shipping");
+        assert_eq!(
+            state.entries[0].updated_at_ms, 4_242,
+            "updated_at_ms stamped from the clock"
+        );
+    }
+
+    #[tokio::test]
+    async fn update_applies_domain_bounds_truncation() {
+        let store = Arc::new(InMemoryLiveStateStore::default());
+        let uc = UpdateLiveState::new(store.clone(), Arc::new(FixedClock(1)));
+
+        let long = "x".repeat(500);
+        uc.execute(UpdateLiveStateInput {
+            agent_id: aid(1),
+            ticket: None,
+            intent: long,
+            status: WorkStatus::Working,
+            progress: None,
+            last_delegation: None,
+        })
+        .await
+        .unwrap();
+
+        let state = store.load().await.unwrap();
+        assert!(
+            state.entries[0].intent.chars().count() <= 200,
+            "soft bound truncated the over-long intent"
+        );
+    }
+
+    #[tokio::test]
+    async fn update_rejects_oversize_field() {
+        let store = Arc::new(InMemoryLiveStateStore::default());
+        let uc = UpdateLiveState::new(store, Arc::new(FixedClock(1)));
+
+        let huge = "x".repeat(FIELD_MAX_BYTES + 1);
+        let err = uc
+            .execute(UpdateLiveStateInput {
+                agent_id: aid(1),
+                ticket: None,
+                intent: huge,
+                status: WorkStatus::Working,
+                progress: None,
+                last_delegation: None,
+            })
+            .await
+            .expect_err("oversize intent must be rejected");
+        assert!(matches!(err, AppError::Invalid(_)));
+    }
+
+    #[tokio::test]
+    async fn get_lean_prunes_on_read_and_returns_lean_dto() {
+        let store = Arc::new(InMemoryLiveStateStore::default());
+        // One fresh row (now-ish) and one ancient row (well beyond the TTL).
+        let now: i64 = 10 * 60 * 60 * 1_000; // 10h in ms
+        store
+            .upsert(
+                LiveEntry::new(
+                    aid(1),
+                    None,
+                    "fresh",
+                    WorkStatus::Working,
+                    Some("detailed progress note".to_owned()),
+                    None,
+                    u64::try_from(now).unwrap(),
+                )
+                .unwrap(),
+            )
+            .await
+            .unwrap();
+        store
+            .upsert(LiveEntry::new(aid(2), None, "stale", WorkStatus::Idle, None, None, 0).unwrap())
+            .await
+            .unwrap();
+
+        let lean = GetLiveStateLean::new(store.clone(), Arc::new(FixedClock(now)))
+            .execute()
+            .await
+            .unwrap();
+
+        // The ancient row (age 10h > 6h TTL) was pruned on read.
+        assert_eq!(lean.entries.len(), 1);
+        let entry = &lean.entries[0];
+        assert_eq!(entry.agent_id, aid(1));
+        assert_eq!(entry.intent, "fresh");
+        assert_eq!(entry.status, WorkStatus::Working);
+
+        // Lean DTO is narrow: no `progress` free-text leaks through. The rich
+        // serialized form must not carry it.
+        let json = serde_json::to_string(&lean).unwrap();
+        assert!(
+            !json.contains("progress"),
+            "lean DTO drops progress: {json}"
+        );
+        assert!(!json.contains("detailed progress note"));
+        assert!(json.contains("\"agentId\""), "camelCase lean DTO");
+
+        // Prune persisted: the store no longer holds the stale row either.
+        assert_eq!(store.load().await.unwrap().entries.len(), 1);
+    }
+}

crates/application/src/workstate/mod.rs

@@ -0,0 +1,528 @@
+//! Read-only project work-state read model.
+//!
+//! This module composes existing runtime state only: the project agent manifest,
+//! live session registries and the input mediator busy state. It performs no I/O
+//! beyond loading the manifest through the existing context store and creates no
+//! durable projection.
+
+mod actions;
+mod live;
+mod reconcile;
+
+pub use actions::{
+    AttachLiveAgent, AttachLiveAgentInput, AttachLiveAgentOutput, StopLiveAgent,
+    StopLiveAgentInput, StopLiveAgentOutput,
+};
+pub use reconcile::{ReconcileLiveState, ReconcileLiveStateInput};
+pub use live::{
+    GetLiveStateLean, LeanLiveEntry, LeanLiveState, UpdateLiveState, UpdateLiveStateInput,
+    LIVE_STATE_MAX_ENTRIES, LIVE_STATE_TTL_MS,
+};
+
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+use domain::input::{AgentBusyState, InputSource};
+use domain::ports::AgentContextStore;
+use domain::{
+    AgentId, AgentQueueSnapshot, ConversationId, ConversationLog, ConversationTurn, Handoff,
+    HandoffStore, InputMediator, NodeId, ProfileId, Project, ProjectPath, QueuedTicketSnapshot,
+    SessionId, TicketId, TurnId, TurnRole,
+};
+
+use crate::error::AppError;
+use crate::terminal::{LiveSessionKind, LiveSessionSnapshot, LiveSessions};
+use crate::HandoffProvider;
+
+/// Maximum length (in characters) of a derived [`AgentTicketState::task_preview`].
+///
+/// The full task can be a very long prompt; the panel only needs a scannable
+/// excerpt, with [`AgentTicketState::task_len`] signalling there is more.
+const TASK_PREVIEW_MAX_CHARS: usize = 160;
+
+/// Maximum length (in characters) of a conversation [`ConversationWorkSummary::summary_preview`].
+const HANDOFF_PREVIEW_MAX_CHARS: usize = 480;
+
+/// Maximum length (in characters) of a conversation [`ConversationWorkSummary::objective_preview`].
+const OBJECTIVE_PREVIEW_MAX_CHARS: usize = 160;
+
+/// Maximum number of recent turns surfaced in a [`ConversationWorkSummary::recent_turns`] fallback.
+const RECENT_TURNS_MAX: usize = 3;
+
+/// Maximum length (in characters) of a [`ConversationTurnWorkPreview::text_preview`].
+const TURN_PREVIEW_MAX_CHARS: usize = 220;
+
+/// Input for [`GetProjectWorkState::execute`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GetProjectWorkStateInput {
+    /// Project whose manifest provides the agent order and boundary.
+    pub project: Project,
+}
+
+/// Read model for a project's current agent work state.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ProjectWorkState {
+    /// Agents in manifest order.
+    pub agents: Vec<AgentWorkState>,
+    /// Best-effort summaries of the conversations visible through the agents'
+    /// tickets, joined frontend-side via `tickets[].conversation_id`. Built from
+    /// the [`HandoffStore`] (primary) with a bounded [`ConversationLog`] fallback;
+    /// a preview failure never blocks `agents`.
+    pub conversations: Vec<ConversationWorkSummary>,
+}
+
+/// Best-effort, read-only summary of one conversation visible through the tickets.
+///
+/// Derived live from the [`HandoffStore`] (primary source) with a bounded
+/// [`ConversationLog`] fallback — never a durable projection, never a repair of the
+/// underlying log/handoff. Joined frontend-side to tickets via
+/// [`ConversationWorkSummary::conversation_id`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConversationWorkSummary {
+    /// The conversation (pair) this summary describes.
+    pub conversation_id: ConversationId,
+    /// How much could be derived (see [`ConversationPreviewStatus`]).
+    pub status: ConversationPreviewStatus,
+    /// Bounded excerpt of the handoff objective, when present.
+    pub objective_preview: Option<String>,
+    /// Bounded excerpt of the handoff summary, when a handoff is readable.
+    pub summary_preview: Option<String>,
+    /// Character length of the **original** (un-truncated) handoff summary (`0` when none).
+    pub summary_len: usize,
+    /// Cursor (last [`TurnId`]) covered by the handoff summary, when present.
+    pub up_to: Option<TurnId>,
+    /// Bounded, recent turns from the log fallback (empty when a handoff is `Ready`).
+    pub recent_turns: Vec<ConversationTurnWorkPreview>,
+}
+
+/// How much of a [`ConversationWorkSummary`] could be derived, best-effort.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ConversationPreviewStatus {
+    /// A handoff was present and usable: summary/objective/cursor are filled.
+    Ready,
+    /// No handoff yet; `recent_turns` carries the log fallback if any.
+    Missing,
+    /// The handoff was unreadable but the log fallback was readable.
+    Partial,
+    /// Neither the handoff nor the log could be read.
+    Unavailable,
+}
+
+/// One recent turn, projected for the conversation-summary fallback.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConversationTurnWorkPreview {
+    /// Nature of the turn (prompt, response, tool activity).
+    pub role: TurnRole,
+    /// Origin of the turn (human operator or a delegating agent).
+    pub source: TicketWorkSource,
+    /// Timestamp (epoch milliseconds) of the turn.
+    pub at_ms: u64,
+    /// Bounded, whitespace-normalised excerpt of the turn text.
+    pub text_preview: String,
+    /// Character length of the **original** (un-truncated) turn text.
+    pub text_len: usize,
+}
+
+/// Builds the [`ConversationLog`] bound to a given project `root`, best-effort.
+///
+/// Twin of [`HandoffProvider`]: the work-state read model is a singleton (the project
+/// root arrives per call via [`GetProjectWorkStateInput`]) while the `Fs*` adapters fix
+/// their root at construction. This port materialises the log targeting the **right**
+/// folder on each call; `None` ⇒ no log fallback (zero regression for call
+/// sites/tests that do not wire it). Implemented in `app-tauri` (sole owner of `Fs*`).
+pub trait ConversationLogProvider: Send + Sync {
+    /// Builds the [`ConversationLog`] whose persistence targets `root`, or `None`.
+    fn conversation_log_for(&self, root: &ProjectPath) -> Option<Arc<dyn ConversationLog>>;
+}
+
+/// Read model for one manifest agent.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AgentWorkState {
+    /// Agent id.
+    pub agent_id: AgentId,
+    /// Agent display name.
+    pub name: String,
+    /// Runtime profile id currently assigned to the agent.
+    pub profile_id: ProfileId,
+    /// Current live session, if the agent is live.
+    pub live: Option<LiveWorkSession>,
+    /// Current FIFO/busy state.
+    pub busy: AgentBusyState,
+    /// Pending/in-progress delegation tickets, in FIFO order.
+    pub tickets: Vec<AgentTicketState>,
+}
+
+/// One queued delegation ticket, projected for the work-state read model.
+///
+/// A read-only, presentation-oriented view of a [`QueuedTicketSnapshot`]: the
+/// status is **derived** by crossing the FIFO snapshot with the agent's busy state
+/// (never stored), and `task_preview` is a bounded excerpt of the full task (the
+/// full text is never sent to the panel; `task_len` signals there is more).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AgentTicketState {
+    /// Stable id of the queued ticket.
+    pub ticket_id: TicketId,
+    /// Conversation thread this task enters.
+    pub conversation_id: ConversationId,
+    /// FIFO position at snapshot time (`0` = head).
+    pub position: u32,
+    /// Derived status (in-progress = the agent's current busy ticket).
+    pub status: TicketWorkStatus,
+    /// Origin of the ticket (human operator or a delegating agent).
+    pub source: TicketWorkSource,
+    /// Display label of the requester.
+    pub requester_label: String,
+    /// Bounded, whitespace-normalised excerpt of the task.
+    pub task_preview: String,
+    /// Character length of the **original** (un-truncated) task.
+    pub task_len: usize,
+}
+
+/// Derived processing status of a queued ticket.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TicketWorkStatus {
+    /// The agent's current busy turn is running this ticket.
+    InProgress,
+    /// Waiting behind the head / the agent is idle.
+    Queued,
+}
+
+/// Origin of a queued ticket, mirroring [`InputSource`] for the read model.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TicketWorkSource {
+    /// The human operator.
+    Human,
+    /// Another agent delegating via `idea_ask_agent`.
+    Agent {
+        /// The delegating agent.
+        agent_id: AgentId,
+    },
+}
+
+impl From<InputSource> for TicketWorkSource {
+    fn from(source: InputSource) -> Self {
+        match source {
+            InputSource::Human => Self::Human,
+            InputSource::Agent { agent_id } => Self::Agent { agent_id },
+        }
+    }
+}
+
+/// Live session coordinates exposed by the work-state read model.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct LiveWorkSession {
+    /// The layout node currently hosting the session view.
+    pub node_id: NodeId,
+    /// The live session id.
+    pub session_id: SessionId,
+    /// Runtime family that owns the session.
+    pub kind: LiveSessionKind,
+}
+
+/// Read-only use case aggregating manifest agents with live and busy state.
+pub struct GetProjectWorkState {
+    contexts: Arc<dyn AgentContextStore>,
+    live: Arc<LiveSessions>,
+    input: Arc<dyn InputMediator>,
+    queue: Arc<dyn AgentQueueSnapshot>,
+    /// Per-root handoff source (primary), wired best-effort; `None` ⇒ no summaries.
+    handoffs: Option<Arc<dyn HandoffProvider>>,
+    /// Per-root log source (fallback), wired best-effort; `None` ⇒ no fallback turns.
+    logs: Option<Arc<dyn ConversationLogProvider>>,
+}
+
+impl GetProjectWorkState {
+    /// Builds the read-model use case from existing stores/registries.
+    ///
+    /// Conversation summaries are off by default; wire them with
+    /// [`Self::with_conversation_sources`].
+    #[must_use]
+    pub fn new(
+        contexts: Arc<dyn AgentContextStore>,
+        live: Arc<LiveSessions>,
+        input: Arc<dyn InputMediator>,
+        queue: Arc<dyn AgentQueueSnapshot>,
+    ) -> Self {
+        Self {
+            contexts,
+            live,
+            input,
+            queue,
+            handoffs: None,
+            logs: None,
+        }
+    }
+
+    /// Wires the best-effort conversation-summary sources (Lot C): the handoff
+    /// store (primary) and the conversation log (bounded fallback), both resolved
+    /// per project root. Builder so existing call sites/tests stay unchanged.
+    #[must_use]
+    pub fn with_conversation_sources(
+        mut self,
+        handoffs: Arc<dyn HandoffProvider>,
+        logs: Arc<dyn ConversationLogProvider>,
+    ) -> Self {
+        self.handoffs = Some(handoffs);
+        self.logs = Some(logs);
+        self
+    }
+
+    /// Executes the read-only aggregation.
+    ///
+    /// # Errors
+    /// - [`AppError::Store`] when the manifest cannot be loaded,
+    /// - [`AppError::Invalid`] if a manifest entry violates agent invariants.
+    pub async fn execute(
+        &self,
+        input: GetProjectWorkStateInput,
+    ) -> Result<ProjectWorkState, AppError> {
+        let manifest = self.contexts.load_manifest(&input.project).await?;
+        let live_by_agent = live_by_agent(self.live.live_agent_snapshots());
+        let agents = manifest
+            .entries
+            .iter()
+            .map(|entry| {
+                let agent = entry
+                    .to_agent()
+                    .map_err(|err| AppError::Invalid(err.to_string()))?;
+                let live = live_by_agent
+                    .get(&agent.id)
+                    .map(|snapshot| LiveWorkSession {
+                        node_id: snapshot.node_id,
+                        session_id: snapshot.session_id,
+                        kind: snapshot.kind,
+                    });
+                // Tickets are crossed with the busy state: only an agent absent from
+                // the manifest is dropped (this loop only visits manifest entries), so
+                // the manifest boundary is naturally preserved.
+                let busy_ticket = self.input.busy_state(agent.id).ticket();
+                let tickets = self
+                    .queue
+                    .queue_for(agent.id)
+                    .into_iter()
+                    .map(|snapshot| ticket_state(snapshot, busy_ticket))
+                    .collect();
+                Ok(AgentWorkState {
+                    agent_id: agent.id,
+                    name: agent.name,
+                    profile_id: agent.profile_id,
+                    live,
+                    busy: self.input.busy_state(agent.id),
+                    tickets,
+                })
+            })
+            .collect::<Result<Vec<_>, AppError>>()?;
+
+        // Lot C — best-effort conversation summaries. Only the conversations
+        // visible through the projected tickets are summarised, deduplicated in
+        // first-seen order. A preview failure degrades the per-conversation status
+        // (never an `AppError`): `agents`/live/busy/tickets stay intact above.
+        let conversations = self
+            .summarise_conversations(&input.project.root, &agents)
+            .await;
+
+        Ok(ProjectWorkState {
+            agents,
+            conversations,
+        })
+    }
+
+    /// Derives the best-effort summaries of the conversations referenced by the
+    /// projected tickets. Resolves the per-root handoff/log stores once, then folds
+    /// each distinct conversation id through [`conversation_summary`].
+    async fn summarise_conversations(
+        &self,
+        root: &ProjectPath,
+        agents: &[AgentWorkState],
+    ) -> Vec<ConversationWorkSummary> {
+        let conversation_ids = distinct_conversation_ids(agents);
+        if conversation_ids.is_empty() {
+            return Vec::new();
+        }
+        let handoff_store = self
+            .handoffs
+            .as_ref()
+            .and_then(|provider| provider.handoff_store_for(root));
+        let log_store = self
+            .logs
+            .as_ref()
+            .and_then(|provider| provider.conversation_log_for(root));
+
+        let mut summaries = Vec::with_capacity(conversation_ids.len());
+        for conversation in conversation_ids {
+            summaries.push(conversation_summary(conversation, &handoff_store, &log_store).await);
+        }
+        summaries
+    }
+}
+
+/// Collects the conversation ids referenced by the agents' tickets, deduplicated in
+/// first-seen (FIFO) order so the summary list mirrors the panel's ordering.
+fn distinct_conversation_ids(agents: &[AgentWorkState]) -> Vec<ConversationId> {
+    let mut seen = HashSet::new();
+    let mut ids = Vec::new();
+    for agent in agents {
+        for ticket in &agent.tickets {
+            if seen.insert(ticket.conversation_id) {
+                ids.push(ticket.conversation_id);
+            }
+        }
+    }
+    ids
+}
+
+/// Derives one conversation summary, best-effort, following the Lot C algorithm:
+/// handoff present ⇒ `Ready`; absent ⇒ `Missing` (+ log fallback); unreadable but
+/// log readable ⇒ `Partial`; both KO ⇒ `Unavailable`. Never returns an error.
+async fn conversation_summary(
+    conversation: ConversationId,
+    handoff_store: &Option<Arc<dyn HandoffStore>>,
+    log_store: &Option<Arc<dyn ConversationLog>>,
+) -> ConversationWorkSummary {
+    // A handoff store absent from the wiring is treated as "no handoff yet"
+    // (`Missing` path), never as an error: the read model stays best-effort.
+    let handoff = match handoff_store {
+        Some(store) => Some(store.load(conversation).await),
+        None => None,
+    };
+    match handoff {
+        Some(Ok(Some(handoff))) => ready_summary(conversation, &handoff),
+        Some(Ok(None)) | None => {
+            // Handoff legitimately absent: status stays Missing even if the log
+            // fallback is itself unreadable (then simply no recent turns).
+            let recent_turns = recent_turns(log_store, conversation)
+                .await
+                .unwrap_or_default();
+            ConversationWorkSummary {
+                conversation_id: conversation,
+                status: ConversationPreviewStatus::Missing,
+                objective_preview: None,
+                summary_preview: None,
+                summary_len: 0,
+                up_to: None,
+                recent_turns,
+            }
+        }
+        Some(Err(_)) => match recent_turns(log_store, conversation).await {
+            // Handoff unreadable but the log answered: partial view from the turns.
+            Some(recent_turns) => ConversationWorkSummary {
+                conversation_id: conversation,
+                status: ConversationPreviewStatus::Partial,
+                objective_preview: None,
+                summary_preview: None,
+                summary_len: 0,
+                up_to: None,
+                recent_turns,
+            },
+            // Both sources failed: nothing usable to show.
+            None => ConversationWorkSummary {
+                conversation_id: conversation,
+                status: ConversationPreviewStatus::Unavailable,
+                objective_preview: None,
+                summary_preview: None,
+                summary_len: 0,
+                up_to: None,
+                recent_turns: Vec::new(),
+            },
+        },
+    }
+}
+
+/// Projects a readable [`Handoff`] into a `Ready` summary with bounded previews.
+fn ready_summary(conversation: ConversationId, handoff: &Handoff) -> ConversationWorkSummary {
+    ConversationWorkSummary {
+        conversation_id: conversation,
+        status: ConversationPreviewStatus::Ready,
+        objective_preview: handoff
+            .objective
+            .as_deref()
+            .map(|objective| preview(objective, OBJECTIVE_PREVIEW_MAX_CHARS)),
+        summary_preview: Some(preview(&handoff.summary_md, HANDOFF_PREVIEW_MAX_CHARS)),
+        summary_len: handoff.summary_md.chars().count(),
+        up_to: Some(handoff.up_to),
+        recent_turns: Vec::new(),
+    }
+}
+
+/// Reads the bounded recent-turns fallback for `conversation`.
+///
+/// Returns `Some(turns)` (possibly empty) when a log store is wired and answers,
+/// `None` when there is no log store or the read failed — the caller uses that
+/// distinction to separate `Partial` from `Unavailable`. Never reads the full thread
+/// (only [`ConversationLog::last`]) and re-caps defensively to [`RECENT_TURNS_MAX`].
+async fn recent_turns(
+    log_store: &Option<Arc<dyn ConversationLog>>,
+    conversation: ConversationId,
+) -> Option<Vec<ConversationTurnWorkPreview>> {
+    let store = log_store.as_ref()?;
+    match store.last(conversation, RECENT_TURNS_MAX).await {
+        Ok(turns) => Some(
+            turns
+                .into_iter()
+                .take(RECENT_TURNS_MAX)
+                .map(turn_preview)
+                .collect(),
+        ),
+        Err(_) => None,
+    }
+}
+
+/// Projects one [`ConversationTurn`] into its bounded read-model preview.
+fn turn_preview(turn: ConversationTurn) -> ConversationTurnWorkPreview {
+    ConversationTurnWorkPreview {
+        role: turn.role,
+        source: turn.source.into(),
+        at_ms: turn.at_ms,
+        text_preview: preview(&turn.text, TURN_PREVIEW_MAX_CHARS),
+        text_len: turn.text.chars().count(),
+    }
+}
+
+/// Projects one FIFO snapshot into a read-model ticket, deriving status from the
+/// agent's current busy ticket (the one running its turn = `InProgress`).
+fn ticket_state(snapshot: QueuedTicketSnapshot, busy_ticket: Option<TicketId>) -> AgentTicketState {
+    let status = if busy_ticket == Some(snapshot.id) {
+        TicketWorkStatus::InProgress
+    } else {
+        TicketWorkStatus::Queued
+    };
+    AgentTicketState {
+        ticket_id: snapshot.id,
+        conversation_id: snapshot.conversation,
+        position: snapshot.position,
+        status,
+        source: snapshot.source.into(),
+        requester_label: snapshot.requester,
+        task_preview: task_preview(&snapshot.task),
+        task_len: snapshot.task.chars().count(),
+    }
+}
+
+/// Builds the bounded task excerpt for the UI panel (see [`preview`]).
+///
+/// The original length is reported separately as [`AgentTicketState::task_len`].
+fn task_preview(task: &str) -> String {
+    preview(task, TASK_PREVIEW_MAX_CHARS)
+}
+
+/// Builds a bounded, whitespace-normalised excerpt of `text` for the UI.
+///
+/// Trims, collapses any run of whitespace to a single space, then truncates to
+/// `max_chars` characters (never mid-codepoint). The original length is reported
+/// separately by each caller's `*_len` field.
+fn preview(text: &str, max_chars: usize) -> String {
+    let normalised = text.split_whitespace().collect::<Vec<_>>().join(" ");
+    if normalised.chars().count() <= max_chars {
+        normalised
+    } else {
+        normalised.chars().take(max_chars).collect()
+    }
+}
+
+fn live_by_agent(snapshots: Vec<LiveSessionSnapshot>) -> HashMap<AgentId, LiveSessionSnapshot> {
+    let mut out = HashMap::new();
+    for snapshot in snapshots {
+        out.entry(snapshot.agent_id).or_insert(snapshot);
+    }
+    out
+}

crates/application/src/workstate/reconcile.rs

@@ -0,0 +1,230 @@
+//! [`ReconcileLiveState`] — réconcilie, à l'**ouverture** d'un projet, les lignes
+//! de live-state **fantômes** : un agent marqué `working`/`waiting`/`blocked`
+//! alors que sa session n'est plus vivante (un crash ne déclenche jamais
+//! `close_project`, donc `open` est le seul filet fiable).
+//!
+//! C'est la **jumelle** de [`super::live::UpdateLiveState`] côté système : là où
+//! `UpdateLiveState` publie une transition déclarée par un agent, cette
+//! réconciliation est un **acte système** du composition root qui appelle le port
+//! [`LiveStateStore`] **directement** — jamais via `OrchestratorCommand::SetWorkState`.
+//! Le self-only de l'outil MCP `idea_workstate_set` (un agent ne peut écrire que sa
+//! propre ligne) est un invariant **de la surface MCP**, pas du store : il reste
+//! préservé par construction, exactement comme `snapshot_running_agents` /
+//! `reconcile_layouts`.
+//!
+//! Le use case est un mince orchestrateur au-dessus de :
+//! - le store du live-state ([`LiveStateStore`], par project root),
+//! - le registre des sessions vivantes ([`LiveAgentRegistry`] — la *même* vérité
+//!   que `GetProjectWorkState`, dépendance restreinte par ISP : on n'a besoin que
+//!   de « cet agent est-il vivant ? »),
+//! - l'opération **pure** du domaine [`LiveState::reconcile_orphans`] (qui porte la
+//!   politique d'orphelin et la réécriture exacte des champs),
+//! - l'horloge ([`Clock`]) pour estampiller `updated_at_ms` (last-writer-wins).
+//!
+//! **Best-effort** : appelé après `reconcile_layouts` dans la chaîne `open_project`,
+//! un échec ne doit jamais bloquer l'ouverture (le call site ignore le résultat).
+//! **Race-safe** : tourne **avant** toute relance d'agent ; toute reprise ultérieure
+//! réécrit la ligne avec un `updated_at_ms` plus frais (LWW).
+
+use std::sync::Arc;
+
+use domain::ports::{Clock, LiveStateStore};
+use domain::ProjectId;
+
+use crate::error::AppError;
+use crate::terminal::LiveAgentRegistry;
+
+/// Input de [`ReconcileLiveState::execute`].
+///
+/// `project_id` identifie le projet **au point d'appel** ; le [`LiveStateStore`]
+/// par-root est lié par le provider du composition root (cf. `AppLiveStateProvider`),
+/// si bien que le flux pur ci-dessous n'a plus de résolution à faire.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ReconcileLiveStateInput {
+    /// Le projet dont le live-state doit être réconcilié.
+    pub project_id: ProjectId,
+}
+
+/// Réconcilie les lignes de live-state fantômes d'un projet à l'ouverture.
+pub struct ReconcileLiveState {
+    store: Arc<dyn LiveStateStore>,
+    registry: Arc<dyn LiveAgentRegistry>,
+    clock: Arc<dyn Clock>,
+}
+
+impl ReconcileLiveState {
+    /// Construit le use case à partir de ses ports injectés (store par-root,
+    /// registre de liveness, horloge).
+    #[must_use]
+    pub fn new(
+        store: Arc<dyn LiveStateStore>,
+        registry: Arc<dyn LiveAgentRegistry>,
+        clock: Arc<dyn Clock>,
+    ) -> Self {
+        Self {
+            store,
+            registry,
+            clock,
+        }
+    }
+
+    /// Charge le live-state, calcule les orphelins via la transformation pure du
+    /// domaine ([`LiveState::reconcile_orphans`]) en croisant chaque ligne avec la
+    /// liveness réelle, puis ré-upsert chaque ligne réécrite (keyed LWW).
+    ///
+    /// `_input` ne sert qu'à l'identité du projet au point d'appel : la racine est
+    /// déjà liée dans le store injecté.
+    ///
+    /// # Errors
+    /// [`AppError::Store`] sur défaillance de chargement ou d'upsert du store.
+    pub async fn execute(&self, _input: ReconcileLiveStateInput) -> Result<(), AppError> {
+        let state = self.store.load().await?;
+        let now_ms = u64::try_from(self.clock.now_millis()).unwrap_or(0);
+        let reconciled = state.reconcile_orphans(|a| self.registry.is_agent_live(a), now_ms);
+        for entry in reconciled {
+            self.store.upsert(entry).await?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::collections::HashSet;
+    use std::sync::Mutex;
+
+    use domain::live_state::{LiveEntry, LiveState, WorkStatus, STALE_AT_RESTART_MARKER};
+    use domain::ports::StoreError;
+    use domain::{AgentId, NodeId};
+
+    /// In-memory [`LiveStateStore`] double (keyed upsert + prune), no I/O.
+    #[derive(Default)]
+    struct InMemoryLiveStateStore {
+        state: Mutex<LiveState>,
+    }
+
+    #[async_trait::async_trait]
+    impl LiveStateStore for InMemoryLiveStateStore {
+        async fn load(&self) -> Result<LiveState, StoreError> {
+            Ok(self.state.lock().unwrap().clone())
+        }
+        async fn upsert(&self, entry: LiveEntry) -> Result<(), StoreError> {
+            self.state.lock().unwrap().upsert(entry);
+            Ok(())
+        }
+        async fn prune(&self, now_ms: u64, ttl_ms: u64, max_n: usize) -> Result<(), StoreError> {
+            self.state.lock().unwrap().prune(now_ms, ttl_ms, max_n);
+            Ok(())
+        }
+    }
+
+    /// Liveness fake: only the agents in the set are considered live.
+    struct FakeRegistry {
+        live: HashSet<AgentId>,
+    }
+    impl LiveAgentRegistry for FakeRegistry {
+        fn is_agent_live(&self, agent_id: &AgentId) -> bool {
+            self.live.contains(agent_id)
+        }
+        fn is_node_live(&self, _node_id: &NodeId) -> bool {
+            false
+        }
+    }
+
+    struct FixedClock(i64);
+    impl Clock for FixedClock {
+        fn now_millis(&self) -> i64 {
+            self.0
+        }
+    }
+
+    fn aid(n: u128) -> AgentId {
+        AgentId::from_uuid(uuid::Uuid::from_u128(n))
+    }
+
+    fn pid() -> ProjectId {
+        ProjectId::from_uuid(uuid::Uuid::from_u128(42))
+    }
+
+    async fn run(store: Arc<InMemoryLiveStateStore>, live: HashSet<AgentId>, now: i64) {
+        let uc = ReconcileLiveState::new(
+            store,
+            Arc::new(FakeRegistry { live }),
+            Arc::new(FixedClock(now)),
+        );
+        uc.execute(ReconcileLiveStateInput { project_id: pid() })
+            .await
+            .unwrap();
+    }
+
+    #[tokio::test]
+    async fn reconciles_orphan_with_dead_session() {
+        let store = Arc::new(InMemoryLiveStateStore::default());
+        store
+            .upsert(
+                LiveEntry::new(aid(1), None, "work", WorkStatus::Working, None, None, 1).unwrap(),
+            )
+            .await
+            .unwrap();
+
+        // No agent live, now = 999.
+        run(store.clone(), HashSet::new(), 999).await;
+
+        let after = store.load().await.unwrap();
+        assert_eq!(after.entries.len(), 1, "still one keyed row (upsert, not append)");
+        let row = &after.entries[0];
+        assert_eq!(row.status, WorkStatus::Idle, "orphan downgraded to idle");
+        assert_eq!(row.progress.as_deref(), Some(STALE_AT_RESTART_MARKER));
+        assert_eq!(row.updated_at_ms, 999, "stamped from the clock");
+    }
+
+    #[tokio::test]
+    async fn spares_a_live_agent() {
+        let store = Arc::new(InMemoryLiveStateStore::default());
+        store
+            .upsert(
+                LiveEntry::new(aid(1), None, "work", WorkStatus::Working, None, None, 7).unwrap(),
+            )
+            .await
+            .unwrap();
+
+        // aid(1) is still live ⇒ untouched.
+        run(store.clone(), HashSet::from([aid(1)]), 999).await;
+
+        let row = &store.load().await.unwrap().entries[0];
+        assert_eq!(row.status, WorkStatus::Working, "live agent left as-is");
+        assert_eq!(row.updated_at_ms, 7, "not restamped");
+    }
+
+    #[tokio::test]
+    async fn empty_store_is_a_noop_at_boot() {
+        // First boot / crashed before any publish ⇒ the live-state file is absent
+        // and `load()` yields an empty state. Reconciliation must be a clean no-op:
+        // no upsert, no panic — `open_project` must never choke on a missing file.
+        let store = Arc::new(InMemoryLiveStateStore::default());
+
+        run(store.clone(), HashSet::new(), 999).await;
+
+        assert!(
+            store.load().await.unwrap().entries.is_empty(),
+            "nothing to reconcile ⇒ store stays empty"
+        );
+    }
+
+    #[tokio::test]
+    async fn leaves_idle_row_unchanged() {
+        let store = Arc::new(InMemoryLiveStateStore::default());
+        store
+            .upsert(LiveEntry::new(aid(1), None, "rest", WorkStatus::Idle, None, None, 3).unwrap())
+            .await
+            .unwrap();
+
+        run(store.clone(), HashSet::new(), 999).await;
+
+        let row = &store.load().await.unwrap().entries[0];
+        assert_eq!(row.status, WorkStatus::Idle);
+        assert_eq!(row.updated_at_ms, 3, "idle row never reconciled, not restamped");
+    }
+}