feat(permissions): voie projection CLI (LP0→LP3) + checkpoint Codex/input

Jalon vert regroupant deux chantiers entrelacés dans le working tree,
indissociables au niveau fichier mais tous deux verts (cargo test
--workspace + tests frontend permissions au vert).

Permissions — voie « projection CLI » (advisory), complète :
- LP0 domaine pur : modèle PermissionSet/EffectivePermissions, resolve
  deny-wins + postures Allow<Ask<Deny (crates/domain/src/permission.rs).
- LP1 store : FsPermissionStore (.ideai/permissions.json).
- LP2 use cases : Get/Update project, Update agent override, Resolve.
- LP3 projecteurs Claude/Codex (settings.local.json / config.toml),
  câblage launch-path + PermissionProjectorRegistry, nettoyage des
  fichiers Replace orphelins au swap de profil (LP3-4), composition root
  + commandes Tauri, UI PermissionsPanel (projet + override agent).
- ports.rs : PermissionStore + FileSystem::remove_file (cleanup au swap).

Reste ouvert (hors scope, marqué dans le code) : LP4 enforcement OS
airtight (Landlock fichiers) + résumé de permissions injecté.

Inclut aussi le chantier Codex/input/sessions structurées en cours
(McpConfigStrategy, StructuredAdapter, gestion d'input) partageant les
mêmes fichiers (lifecycle.rs, commands.rs, dto.rs, state.rs).

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

crates/domain/src/input.rs

@@ -211,6 +211,45 @@ pub trait InputMediator: Send + Sync {
         false
     }
 
+    /// Déclare qu'`agent` vient d'être **lancé à froid** : la livraison de son tout
+    /// premier tour doit être *gatée* sur le prompt-ready (la `DelegationReady` est
+    /// différée jusqu'à l'apparition du prompt du CLI), pour éviter d'écrire la tâche
+    /// avant que le CLI ait fini de booter (premier tour perdu sinon).
+    ///
+    /// À n'appeler **que** lorsqu'un prompt-ready watcher sera effectivement armé (le
+    /// profil porte un `prompt_ready_pattern` non vide). Sans watcher pour le libérer,
+    /// gater le premier tour le bloquerait indéfiniment ; dans ce cas l'orchestrateur ne
+    /// doit **pas** appeler `mark_starting` et l'`enqueue` livre la tâche immédiatement
+    /// (chemin chaud, fallback sûr, zéro régression).
+    ///
+    /// Default: no-op (a mediator that does not gate cold starts).
+    fn mark_starting(&self, _agent: AgentId) {}
+
+    /// Signal de **readiness de démarrage** : le pont MCP de `agent` vient de se
+    /// connecter (son CLI est up et a chargé les outils `idea_*`). Si un premier tour
+    /// a été différé par [`InputMediator::mark_starting`] (démarrage à froid), c'est le
+    /// moment de le livrer ⇒ draine le `DelegationReady` retenu. **Contrairement à
+    /// `prompt_ready`, aucun repli `mark_idle`** : c'est un signal de DÉMARRAGE, pas de
+    /// fin de tour. Idempotent : un second appel (ou après que `prompt_ready` ait déjà
+    /// drainé) ne trouve rien et est un no-op. En OR avec le prompt-ready : le premier
+    /// arrivé draine, l'autre est no-op.
+    ///
+    /// Default: no-op (médiateur qui ne gate pas les démarrages à froid).
+    fn release_cold_start(&self, _agent: AgentId) {}
+
+    /// Déclare si une **cellule terminal du frontend** est montée pour `agent`
+    /// (`true` au montage du write-portal, `false` au démontage). C'est le frontend
+    /// qui possède l'écriture physique du PTY *quand une cellule existe* (cas d'un
+    /// agent épinglé dans le layout) ; un agent **délégué en arrière-plan n'a aucune
+    /// cellule**, donc personne ne consomme `DelegationReady` côté UI. Le médiateur
+    /// utilise cet état pour décider, à la livraison d'un tour, entre **publier
+    /// l'événement** (cellule présente ⇒ le front écrit) et **écrire lui-même** la
+    /// tâche dans le PTY (agent headless ⇒ sinon le tour est perdu).
+    ///
+    /// Default: no-op (médiateur sans notion de cellule front — tout passe par
+    /// l'événement, comportement historique).
+    fn set_front_attached(&self, _agent: AgentId, _attached: bool) {}
+
     /// Interrompre = preempt: signals the running turn to stop (Échap/stop). This
     /// is **not** an enqueue and correlates **no** ticket.
     fn preempt(&self, agent: AgentId);