feat(agents): pont Codex inter-agents + readiness/heartbeat lot 1

Deux chantiers livrés au vert (workspace entier : domain+application+
infrastructure 42 + app-tauri --lib 128, 0 échec).

## Codex inter-agents
- domaine: McpConfigStrategy::TomlConfigHome { target, home_env } +
  toml_config_home(...); AgentProfile::materializes_idea_bridge()
  (whitelist Claude/ConfigFile + Codex/TomlConfigHome); McpServerWiring
  + encodeur TOML.
- application: lifecycle apply_mcp_config bras TomlConfigHome (écrit
  {runDir}/<target>, pousse (home_env, parent) dans spec.env);
  guard_mcp_bridge_supported ré-exprimée via materializes_idea_bridge();
  catalogue Codex porte toml_config_home(".codex/config.toml","CODEX_HOME").
- app-tauri: is_codex_mcp_profile, migrate_codex_run_dir,
  mcp_server_entry_toml.
- tests: matrice domaine TomlConfigHome + round-trip dual Claude/Codex
  sur loopback réel (fakes, zéro token).

## Readiness/heartbeat lot 1
- domaine: readiness.rs — ReadinessPolicy::classify (Final => TurnEnded),
  variantes ReplyEvent::Heartbeat / ToolActivity.
- application: drain_with_readiness consulte la policy et appelle
  mark_idle sur le signal déterministe; branché dans ask_agent.
  Corrige la cause racine: une cible qui ne renvoie qu'un Final (sans
  idea_reply) débloque désormais sa file Busy.
- infrastructure: adapters de session émettent Heartbeat/ToolActivity.
- tests: drain_with_readiness_lot1 (points QA 5 & 6) verts.

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

crates/infrastructure/src/session/codex.rs

@@ -43,13 +43,13 @@ pub struct ParsedLine {
 ///
 /// - `{"type":"thread.started","thread_id":"<id>"}` ⇒ capte le `thread_id`
 ///   (= id de conversation pour la reprise), **aucun** événement émis.
-/// - `{"type":"turn.started"}` ⇒ ignoré.
+/// - `{"type":"turn.started"}` ⇒ [`ReplyEvent::Heartbeat`] (vivacité non terminale).
 /// - `{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"…"}}`
 ///   ⇒ si `item.type=="agent_message"` ⇒ [`ReplyEvent::Final`] (`content` = `item.text`,
 ///   c'est la réponse) ; sinon (`reasoning`/`command`/autre) ⇒
 ///   [`ReplyEvent::ToolActivity`] (`label` = `item.type`).
-/// - `{"type":"turn.completed","usage":{…}}` ⇒ ignoré (le `Final` vient de
-///   l'`agent_message`).
+/// - `{"type":"turn.completed","usage":{…}}` ⇒ [`ReplyEvent::Heartbeat`] (le `Final`
+///   vient de l'`agent_message`, pas de `turn.completed`).
 ///
 /// Ligne vide ⇒ ignorée ; type inconnu ⇒ ignoré sans erreur ; JSON illisible ⇒
 /// [`AgentSessionError::Decode`] (jamais de JSON brut propagé).
@@ -75,6 +75,10 @@ pub fn parse_event(line: &str) -> Result<ParsedLine, AgentSessionError> {
                 .and_then(Value::as_str)
                 .map(str::to_owned);
         }
+        // Début/fin de tour côté moteur : pas de contenu, mais preuve de vivacité ⇒
+        // battement de cœur non terminal (readiness/heartbeat lot 1). Le `Final` vient
+        // toujours de l'`agent_message`, jamais de `turn.completed`.
+        Some("turn.started") | Some("turn.completed") => events.push(ReplyEvent::Heartbeat),
         Some("item.completed") => {
             if let Some(item) = value.get("item") {
                 match item.get("type").and_then(Value::as_str) {
@@ -94,7 +98,7 @@ pub fn parse_event(line: &str) -> Result<ParsedLine, AgentSessionError> {
                 }
             }
         }
-        // turn.started / turn.completed / type inconnu : ignoré (robustesse).
+        // type inconnu : ignoré (robustesse).
         _ => {}
     }
 
@@ -192,12 +196,21 @@ impl AgentSession for CodexExecSession {
 
         let mut events = Vec::new();
         let mut captured_id = None;
-        for line in &raw_lines {
+        'lines: for line in &raw_lines {
             let parsed = parse_event(line)?;
             if let Some(id) = parsed.conversation_id {
                 captured_id = Some(id);
             }
-            events.extend(parsed.events);
+            // Le `Final` est **terminal** (contrat de port) : on arrête d'émettre dès
+            // qu'on l'a vu, pour qu'aucun heartbeat de fin (`turn.completed` postérieur)
+            // ne le suive dans le flux.
+            for event in parsed.events {
+                let is_final = matches!(event, ReplyEvent::Final { .. });
+                events.push(event);
+                if is_final {
+                    break 'lines;
+                }
+            }
         }
         if let Some(id) = captured_id {
             *self.conversation_id.lock().expect("mutex sain") = Some(id);