docs: update AMELIORATIONS.md and ORCHESTRATE agents based on current codebase state

- AMELIORATIONS.md: Complete rewrite reflecting actual implemented features
  - Document 25+ features already implemented (cortex-commands, cortex-agents,
    cortex-hooks, cortex-network-proxy, cortex-share, cortex-review, etc.)
  - Update comparison tables with accurate status
  - Identify remaining critical gaps: Background Agents, Task DAG, SDK, Slack, etc.
  - Remove outdated sections, add clear prioritization

- ORCHESTRATE/: New agent specifications (1-10) focused on remaining gaps
  - AGENT_1: Background Agents & Async Messaging
  - AGENT_2: Task DAG System
  - AGENT_3: SDK TypeScript
  - AGENT_4: Slack Integration
  - AGENT_5: Linear/Jira Integration
  - AGENT_6: Auto-Compaction Intelligent
  - AGENT_7: /init Auto-AGENTS.md
  - AGENT_8: MCP Registry Browser
  - AGENT_9: Skills System Complet
  - AGENT_10: Live Task Progress

- Exclude Chrome Browser and Provider Support as per user request

Author: factorydroid

AMELIORATIONS.md

@@ -0,0 +1,365 @@
+# AGENT_1: Background Agents & Async Messaging
+
+## Mission
+
+Implémenter l'exécution véritablement parallèle d'agents en arrière-plan avec communication asynchrone entre agents.
+
+## Contexte
+
+**Priorité:** 🔴 Critique  
+**Effort estimé:** 6-8 jours développeur  
+**Présent dans:** Claude Code (v2.0.64+), Droid
+
+## État Actuel dans cortex-cli
+
+### Ce qui existe déjà ✅
+
+- `cortex-agents/routing.rs`:
+  - `DispatchMode::Background` enum variant
+  - `DispatchMode::Parallel` enum variant
+  - `TaskInfo` avec métadonnées de tâches
+  - `RoutingDecision` pour décisions de dispatch
+  - `decide_routing()` pour routing intelligent
+
+- `cortex-agents/agent.rs`:
+  - `AgentMode::Background` enum variant
+  - `AgentInfo` avec configuration complète
+
+### Ce qui manque ❌
+
+- Exécution réelle des agents en background (tokio tasks)
+- Communication async entre agents (channels)
+- UI `/tasks` pour monitoring des agents
+- Ctrl+B pour lancer en arrière-plan
+- Notifications quand un agent termine
+
+## Objectifs Spécifiques
+
+### 1. Background Agent Executor
+
+```rust
+// cortex-agents/src/background/executor.rs
+
+use tokio::sync::{mpsc, oneshot, broadcast};
+use std::collections::HashMap;
+
+/// Manager des agents en arrière-plan
+pub struct BackgroundAgentManager {
+    agents: HashMap<String, BackgroundAgent>,
+    event_tx: broadcast::Sender<AgentEvent>,
+    max_concurrent: usize,
+}
+
+pub struct BackgroundAgent {
+    id: String,
+    handle: tokio::task::JoinHandle<AgentResult>,
+    status_rx: mpsc::Receiver<AgentStatus>,
+    cancel_tx: oneshot::Sender<()>,
+    started_at: Instant,
+}
+
+#[derive(Clone, Debug)]
+pub enum AgentEvent {
+    Started { id: String, task: String },
+    Progress { id: String, message: String },
+    Completed { id: String, result: AgentResult },
+    Failed { id: String, error: String },
+}
+
+impl BackgroundAgentManager {
+    pub fn new(max_concurrent: usize) -> Self { ... }
+    
+    /// Lance un agent en arrière-plan
+    pub async fn spawn(&mut self, config: AgentConfig) -> Result<String, AgentError> {
+        if self.agents.len() >= self.max_concurrent {
+            return Err(AgentError::TooManyAgents);
+        }
+        
+        let id = uuid::Uuid::new_v4().to_string();
+        let (status_tx, status_rx) = mpsc::channel(100);
+        let (cancel_tx, cancel_rx) = oneshot::channel();
+        
+        let event_tx = self.event_tx.clone();
+        let handle = tokio::spawn(async move {
+            run_background_agent(config, status_tx, cancel_rx, event_tx).await
+        });
+        
+        self.agents.insert(id.clone(), BackgroundAgent {
+            id: id.clone(),
+            handle,
+            status_rx,
+            cancel_tx,
+            started_at: Instant::now(),
+        });
+        
+        Ok(id)
+    }
+    
+    /// Liste les agents actifs
+    pub fn list(&self) -> Vec<AgentStatus> { ... }
+    
+    /// Attend qu'un agent termine
+    pub async fn wait(&mut self, id: &str, timeout: Duration) -> Result<AgentResult> { ... }
+    
+    /// Annule un agent
+    pub async fn cancel(&mut self, id: &str) -> Result<()> { ... }
+    
+    /// S'abonne aux événements
+    pub fn subscribe(&self) -> broadcast::Receiver<AgentEvent> {
+        self.event_tx.subscribe()
+    }
+}
+```
+
+### 2. Async Messaging Between Agents
+
+```rust
+// cortex-agents/src/background/messaging.rs
+
+use tokio::sync::mpsc;
+
+/// Channel pour communication inter-agents
+pub struct AgentMailbox {
+    inbox: mpsc::Receiver<AgentMessage>,
+    outbox: mpsc::Sender<AgentMessage>,
+}
+
+#[derive(Clone, Debug)]
+pub struct AgentMessage {
+    pub from: String,
+    pub to: String,
+    pub content: MessageContent,
+    pub timestamp: Instant,
+}
+
+#[derive(Clone, Debug)]
+pub enum MessageContent {
+    /// Notification simple
+    Notify(String),
+    /// Demande avec réponse attendue
+    Request { id: String, payload: String },
+    /// Réponse à une demande
+    Response { request_id: String, payload: String },
+    /// Partage de données
+    Data { key: String, value: serde_json::Value },
+}
+
+impl AgentMailbox {
+    /// Envoie un message à un autre agent
+    pub async fn send(&self, to: &str, content: MessageContent) -> Result<()> { ... }
+    
+    /// Reçoit le prochain message (non-bloquant)
+    pub fn try_recv(&mut self) -> Option<AgentMessage> { ... }
+    
+    /// Attend un message (avec timeout)
+    pub async fn recv_timeout(&mut self, timeout: Duration) -> Option<AgentMessage> { ... }
+}
+```
+
+### 3. TUI /tasks Command
+
+```rust
+// cortex-tui/src/views/tasks.rs
+
+use ratatui::widgets::{Table, Row, Cell};
+
+pub struct TasksView {
+    agents: Vec<AgentStatus>,
+    selected: usize,
+}
+
+impl TasksView {
+    pub fn render(&self, frame: &mut Frame, area: Rect) {
+        let header = Row::new(vec!["ID", "Status", "Task", "Duration", "Tokens"]);
+        
+        let rows: Vec<Row> = self.agents.iter().map(|agent| {
+            Row::new(vec![
+                Cell::from(agent.id.chars().take(8).collect::<String>()),
+                Cell::from(status_badge(&agent.status)),
+                Cell::from(truncate(&agent.task, 40)),
+                Cell::from(format_duration(agent.duration)),
+                Cell::from(format!("{}", agent.tokens_used)),
+            ])
+        }).collect();
+        
+        let table = Table::new(rows)
+            .header(header)
+            .widths(&[
+                Constraint::Length(10),
+                Constraint::Length(12),
+                Constraint::Percentage(40),
+                Constraint::Length(10),
+                Constraint::Length(10),
+            ]);
+            
+        frame.render_widget(table, area);
+    }
+}
+
+fn status_badge(status: &AgentStatus) -> Span {
+    match status {
+        AgentStatus::Running => Span::styled("● Running", Style::default().fg(Color::Yellow)),
+        AgentStatus::Completed => Span::styled("✓ Done", Style::default().fg(Color::Green)),
+        AgentStatus::Failed => Span::styled("✗ Failed", Style::default().fg(Color::Red)),
+        AgentStatus::Cancelled => Span::styled("○ Cancelled", Style::default().fg(Color::Gray)),
+    }
+}
+```
+
+### 4. Ctrl+B Handler
+
+```rust
+// cortex-tui/src/input/keybindings.rs
+
+// Ajouter dans le handler de touches
+KeyCode::Char('b') if modifiers.contains(KeyModifiers::CONTROL) => {
+    // Lancer la tâche courante en arrière-plan
+    if let Some(prompt) = self.get_current_prompt() {
+        let agent_id = self.background_manager
+            .spawn(AgentConfig::background(prompt))
+            .await?;
+        self.show_notification(format!("Agent {} lancé en arrière-plan", &agent_id[..8]));
+    }
+    InputAction::Handled
+}
+```
+
+### 5. Notification System
+
+```rust
+// cortex-tui/src/notifications.rs
+
+pub struct NotificationManager {
+    event_rx: broadcast::Receiver<AgentEvent>,
+    pending: VecDeque<Notification>,
+}
+
+impl NotificationManager {
+    pub async fn poll(&mut self) {
+        while let Ok(event) = self.event_rx.try_recv() {
+            match event {
+                AgentEvent::Completed { id, result } => {
+                    self.pending.push_back(Notification {
+                        title: format!("Agent {} terminé", &id[..8]),
+                        body: result.summary,
+                        level: NotificationLevel::Info,
+                    });
+                }
+                AgentEvent::Failed { id, error } => {
+                    self.pending.push_back(Notification {
+                        title: format!("Agent {} échoué", &id[..8]),
+                        body: error,
+                        level: NotificationLevel::Error,
+                    });
+                }
+                _ => {}
+            }
+        }
+    }
+}
+```
+
+## Fichiers à Créer
+
+```
+cortex-agents/src/
+├── background/
+│   ├── mod.rs
+│   ├── executor.rs     # BackgroundAgentManager
+│   ├── messaging.rs    # AgentMailbox, inter-agent comm
+│   └── events.rs       # AgentEvent, notifications
+
+cortex-tui/src/
+├── views/
+│   └── tasks.rs        # /tasks view
+├── notifications.rs    # Notification system
+```
+
+## Fichiers à Modifier
+
+1. `cortex-agents/src/lib.rs` - Export du module background
+2. `cortex-agents/Cargo.toml` - Ajouter tokio, uuid
+3. `cortex-tui/src/commands/registry.rs` - Ajouter /tasks
+4. `cortex-tui/src/commands/executor.rs` - Handler /tasks
+5. `cortex-tui/src/input/keybindings.rs` - Ctrl+B
+6. `cortex-tui/src/app.rs` - Intégrer NotificationManager
+
+## Tests Requis
+
+```rust
+#[cfg(test)]
+mod tests {
+    #[tokio::test]
+    async fn test_spawn_background_agent() {
+        let mut manager = BackgroundAgentManager::new(5);
+        let id = manager.spawn(AgentConfig::test()).await.unwrap();
+        assert!(!id.is_empty());
+        assert_eq!(manager.list().len(), 1);
+    }
+    
+    #[tokio::test]
+    async fn test_max_concurrent_limit() {
+        let mut manager = BackgroundAgentManager::new(2);
+        manager.spawn(AgentConfig::test()).await.unwrap();
+        manager.spawn(AgentConfig::test()).await.unwrap();
+        assert!(manager.spawn(AgentConfig::test()).await.is_err());
+    }
+    
+    #[tokio::test]
+    async fn test_agent_cancellation() {
+        let mut manager = BackgroundAgentManager::new(5);
+        let id = manager.spawn(AgentConfig::long_running()).await.unwrap();
+        manager.cancel(&id).await.unwrap();
+        let status = manager.get_status(&id);
+        assert!(matches!(status, AgentStatus::Cancelled));
+    }
+    
+    #[tokio::test]
+    async fn test_inter_agent_messaging() {
+        let (mailbox1, mailbox2) = create_connected_mailboxes();
+        mailbox1.send("agent2", MessageContent::Notify("hello".into())).await.unwrap();
+        let msg = mailbox2.recv_timeout(Duration::from_secs(1)).await.unwrap();
+        assert!(matches!(msg.content, MessageContent::Notify(_)));
+    }
+}
+```
+
+## Sécurité
+
+### Limites
+
+- Max 5 agents concurrent par défaut (configurable)
+- Timeout automatique après 30 minutes
+- Isolation de contexte entre agents
+- Pas d'accès aux credentials d'autres agents
+
+### Cleanup
+
+- RAII: agents cleanup automatique à la fin de session
+- Cancel propre avec timeout de grace (5s)
+- Pas de zombie processes
+
+## Critères de Succès
+
+- [ ] Agents s'exécutent vraiment en parallèle (tokio tasks)
+- [ ] Communication async fonctionne
+- [ ] /tasks affiche les agents actifs
+- [ ] Ctrl+B lance en arrière-plan
+- [ ] Notifications quand agents terminent
+- [ ] Tests passent
+- [ ] Pas de memory leaks
+
+## Estimation
+
+| Tâche | Durée |
+|-------|-------|
+| BackgroundAgentManager | 2 jours |
+| Inter-agent messaging | 1.5 jours |
+| TUI /tasks view | 1 jour |
+| Ctrl+B + notifications | 1 jour |
+| Tests et documentation | 1.5 jours |
+| **Total** | **7 jours** |
+
+---
+
+*Agent autonome - Pas de dépendance externe*