@ranker/raxflow 2.0.5 → 2.1.1

package/dist/tui/hooks/useAppState.js

@@ -3,99 +3,111 @@ import { createOrchestrator } from "../services/orchestrator.js";
 import { setTheme } from "../styles/colors.js";
 const COMMAND_SUGGESTIONS = [
     "stop", "retry", "clear", "session", "evolve",
-    "theme", "toggle", "history", "config", "help", "exit",
+    "theme", "toggle", "history", "config", "providers", "help", "exit",
 ];
-const DEFAULT_AGENTS = [
-    { name: "IntentClassifier", role: "Classify intent", status: "idle", provider: "H" },
-    { name: "TaskPlanner", role: "Decompose tasks", status: "idle", provider: "H" },
-    { name: "SpecAgent", role: "Write specs", status: "idle", provider: "H" },
-    { name: "CodeGenerator", role: "Generate code", status: "idle", provider: "H" },
-    { name: "TestAgent", role: "Run tests", status: "idle", provider: "H" },
-    { name: "FixAgent", role: "Fix issues", status: "idle", provider: "H" },
-    { name: "MutationAgent", role: "Evolve workflow", status: "idle", provider: "H" },
-    { name: "ValidatorAgent", role: "Validate outputs", status: "idle", provider: "H" },
+const AVAILABLE_PROVIDERS = [
+    { name: "Host-Native", env: "HOST_BRIDGE", model: "claude-sonnet-4" },
+    { name: "OpenAI", env: "OPENAI_API_KEY", model: "gpt-4o" },
+    { name: "Anthropic", env: "ANTHROPIC_API_KEY", model: "claude-3-opus" },
+    { name: "Gemini", env: "GOOGLE_API_KEY", model: "gemini-pro" },
+    { name: "Groq", env: "GROQ_API_KEY", model: "llama-3" },
 ];
-const DEFAULT_PROVIDERS = [
-    { name: "Host-Native", status: "active", latency: 12, model: "claude-sonnet-4" },
-    { name: "Claude Code", status: "active", latency: 8, model: "claude-sonnet-4" },
-    { name: "OpenCode", status: "idle", latency: 0, model: "gpt-4o" },
-    { name: "Anthropic", status: "idle", latency: 0, model: "claude-3-opus" },
-];
-const DEFAULT_WORKFLOW_STATE = {
-    levels: [
-        {
-            name: "L1: SPEC",
-            progress: 0,
-            nodes: [
-                { id: "intent", name: "IntentClassifier", status: "pending", agent: "H" },
-                { id: "spec", name: "SpecAgent", status: "pending", agent: "H" },
-                { id: "arch", name: "ArchitectureAgent", status: "pending", agent: "H" },
-            ],
-        },
-        {
-            name: "L2: CODE",
-            progress: 0,
-            nodes: [
-                { id: "task", name: "TaskPlanner", status: "pending", agent: "H" },
-                { id: "codegen", name: "CodeGenerator", status: "pending", agent: "H" },
-            ],
-        },
-        {
-            name: "L3: TEST",
-            progress: 0,
-            nodes: [
-                { id: "test", name: "TestAgent", status: "pending", agent: "H" },
-                { id: "fix", name: "FixAgent", status: "pending", agent: "H" },
-            ],
-        },
-    ],
-    currentLevel: 0,
-    totalProgress: 0,
-};
 function generateId() {
     return Math.random().toString(36).slice(2, 9);
 }
+function detectProviders() {
+    return AVAILABLE_PROVIDERS.map((p) => {
+        const hasKey = process.env[p.env] || (p.name === "Host-Native");
+        return {
+            name: p.name,
+            status: hasKey ? "active" : "idle",
+            latency: hasKey ? Math.floor(Math.random() * 50) + 10 : 0,
+            model: p.model,
+            requests: 0,
+        };
+    });
+}
+function detectProjectName() {
+    try {
+        const cwd = process.cwd();
+        return cwd.split("/").pop() || "project";
+    }
+    catch {
+        return "project";
+    }
+}
+function detectModel() {
+    if (process.env.ANTHROPIC_API_KEY)
+        return "claude-3-opus";
+    if (process.env.OPENAI_API_KEY)
+        return "gpt-4o";
+    if (process.env.GOOGLE_API_KEY)
+        return "gemini-pro";
+    if (process.env.GROQ_API_KEY)
+        return "llama-3";
+    return "host-native";
+}
+const EMPTY_WORKFLOW_STATE = {
+    levels: [],
+    currentLevel: -1,
+    totalProgress: 0,
+    nodeCount: 0,
+};
+const EMPTY_MEMORY_STATE = {
+    nodes: [],
+    edges: [],
+    nodeCount: 0,
+    cacheHitRate: 0,
+};
 export function useAppState() {
     const orchestratorRef = useRef(createOrchestrator());
-    const [state, setState] = useState({
-        projectName: process.cwd().split("/").pop() || "project",
-        agentCount: 12,
-        provider: "HOST-NATIVE",
-        model: "claude-sonnet-4",
-        status: "ready",
-        messages: [
-            {
-                id: generateId(),
-                type: "system",
-                content: "RAXFLOW HUB prêt. Tapez votre prompt ou 'help' pour les commandes.",
-                timestamp: new Date(),
-                model: "claude-sonnet-4",
+    const nodeTimingsRef = useRef(new Map());
+    const [state, setState] = useState(() => {
+        const providers = detectProviders();
+        const activeProvider = providers.find((p) => p.status === "active")?.name || "Host-Native";
+        return {
+            projectName: detectProjectName(),
+            agentCount: 0,
+            provider: activeProvider,
+            model: detectModel(),
+            status: "ready",
+            messages: [
+                {
+                    id: generateId(),
+                    type: "system",
+                    content: "RAXFLOW HUB ready. Enter a prompt or type 'help' for commands.",
+                    timestamp: new Date(),
+                    model: detectModel(),
+                },
+            ],
+            agents: [],
+            providers,
+            fitness: 0.85,
+            currentWorkflow: null,
+            suggestions: COMMAND_SUGGESTIONS,
+            isProcessing: false,
+            workflowState: EMPTY_WORKFLOW_STATE,
+            logs: [],
+            metrics: {
+                sessions: 0,
+                avgDuration: 0,
+                successRate: 100,
+                totalCost: 0,
+                totalRetries: 0,
+                totalEscalations: 0,
+                totalTokens: 0,
+                confidenceAvg: 0,
+            },
+            memory: EMPTY_MEMORY_STATE,
+            theme: "default",
+            sessions: [],
+            viewMode: "full",
+            interactiveCommand: {
+                type: null,
+                options: [],
+                selectedIndex: 0,
             },
-        ],
-        agents: DEFAULT_AGENTS,
-        providers: DEFAULT_PROVIDERS,
-        fitness: 0.87,
-        currentWorkflow: null,
-        suggestions: COMMAND_SUGGESTIONS,
-        isProcessing: false,
-        workflowState: DEFAULT_WORKFLOW_STATE,
-        logs: [],
-        metrics: {
-            sessions: 0,
-            avgDuration: 0,
-            successRate: 100,
-            totalCost: 0,
-            totalRetries: 0,
-            totalEscalations: 0,
-        },
-        theme: "default",
-        sessions: [],
-        viewMode: "full",
-        interactiveCommand: {
-            type: null,
-            options: [],
-            selectedIndex: 0,
-        },
+        };
     });
     useEffect(() => {
         const unsubscribe = orchestratorRef.current.onEvent((event) => {
@@ -103,49 +115,118 @@ export function useAppState() {
         });
         return unsubscribe;
     }, []);
+    const addLog = useCallback((log) => {
+        setState((prev) => ({
+            ...prev,
+            logs: [...prev.logs.slice(-200), log],
+        }));
+    }, []);
+    const addMessage = useCallback((type, content, agent, model) => {
+        setState((prev) => ({
+            ...prev,
+            messages: [
+                ...prev.messages,
+                { id: generateId(), type, content, timestamp: new Date(), agent, model: model || prev.model },
+            ],
+        }));
+    }, []);
     const handleOrchestratorEvent = useCallback((event) => {
         const timestamp = new Date();
-        const timeStr = timestamp.toLocaleTimeString("fr-FR", {
+        const timeStr = timestamp.toLocaleTimeString("en-US", {
             hour: "2-digit",
             minute: "2-digit",
             second: "2-digit",
+            hour12: false,
         });
         switch (event.type) {
             case "run_start":
-                addLog(`[${timeStr}] [START] Task ${event.taskId}`);
-                setState((prev) => ({ ...prev, status: "running", isProcessing: true }));
+                addLog(`[${timeStr}] ▶ START Task ${event.taskId}`);
+                nodeTimingsRef.current.clear();
+                setState((prev) => ({
+                    ...prev,
+                    status: "running",
+                    isProcessing: true,
+                    currentWorkflow: event.taskId,
+                    workflowState: event.workflow ? buildWorkflowFromGraph(event.workflow) : prev.workflowState,
+                }));
                 break;
             case "graph_ready":
-                addLog(`[${timeStr}] [GRAPH] Workflow ready with ${event.workflow.nodes.length} nodes`);
+                addLog(`[${timeStr}] ◆ GRAPH Ready with ${event.workflow.nodes.length} nodes`);
+                setState((prev) => ({
+                    ...prev,
+                    workflowState: buildWorkflowFromGraph(event.workflow),
+                    agentCount: event.workflow.nodes.length,
+                }));
                 break;
             case "node_start":
-                addLog(`[${timeStr}] [RUN] ${event.agent} starting...`);
-                updateAgentStatus(event.agent, "running");
-                updateDAGNode(event.nodeId, "running");
+                addLog(`[${timeStr}] ◐ RUN ${event.agent} (node: ${event.nodeId})`);
+                nodeTimingsRef.current.set(event.nodeId, Date.now());
+                setState((prev) => {
+                    const updatedAgents = updateAgentInList(prev.agents, event.agent, "running");
+                    const updatedWorkflow = updateNodeStatus(prev.workflowState, event.nodeId, "running");
+                    return {
+                        ...prev,
+                        agents: updatedAgents,
+                        workflowState: updatedWorkflow,
+                    };
+                });
                 break;
             case "node_end":
+                const nodeDuration = nodeTimingsRef.current.has(event.nodeId)
+                    ? Date.now() - nodeTimingsRef.current.get(event.nodeId)
+                    : 0;
                 if (event.success) {
-                    addLog(`[${timeStr}] [OK] ${event.agent} done (confidence: ${event.confidence.toFixed(2)})`);
-                    updateAgentStatus(event.agent, "done");
-                    updateDAGNode(event.nodeId, "done");
+                    addLog(`[${timeStr}] ● OK ${event.agent} (${nodeDuration}ms, confidence: ${event.confidence.toFixed(2)})`);
                 }
                 else {
-                    addLog(`[${timeStr}] [FAIL] ${event.agent} failed`);
-                    updateAgentStatus(event.agent, "idle");
-                    updateDAGNode(event.nodeId, "error");
+                    addLog(`[${timeStr}] ✗ FAIL ${event.agent} (retry: ${event.retry})`);
                 }
+                setState((prev) => {
+                    const status = event.success ? "done" : "error";
+                    const updatedAgents = updateAgentInList(prev.agents, event.agent, status, event.confidence);
+                    const updatedWorkflow = updateNodeStatus(prev.workflowState, event.nodeId, status, event.confidence);
+                    const updatedProviders = incrementProviderRequests(prev.providers, prev.provider);
+                    const newTokens = prev.metrics.totalTokens + (event.usage?.totalTokens || 0);
+                    const newCost = prev.metrics.totalCost + (event.costUsd || 0);
+                    return {
+                        ...prev,
+                        agents: updatedAgents,
+                        workflowState: updatedWorkflow,
+                        providers: updatedProviders,
+                        metrics: {
+                            ...prev.metrics,
+                            totalTokens: newTokens,
+                            totalCost: newCost,
+                        },
+                    };
+                });
                 break;
             case "node_error":
-                addLog(`[${timeStr}] [ERR] ${event.agent}: ${event.message}`);
-                updateDAGNode(event.nodeId, "error");
+                addLog(`[${timeStr}] ✗ ERR ${event.agent}: ${event.message}`);
+                setState((prev) => {
+                    const updatedAgents = updateAgentInList(prev.agents, event.agent, "idle");
+                    const updatedWorkflow = updateNodeStatus(prev.workflowState, event.nodeId, "error");
+                    return {
+                        ...prev,
+                        agents: updatedAgents,
+                        workflowState: updatedWorkflow,
+                        metrics: {
+                            ...prev.metrics,
+                            totalRetries: prev.metrics.totalRetries + 1,
+                        },
+                    };
+                });
                 break;
             case "run_end":
-                addLog(`[${timeStr}] [DONE] Task completed (confidence: ${event.metrics.confidence.toFixed(2)})`);
+                addLog(`[${timeStr}] ■ DONE (confidence: ${event.metrics.confidence.toFixed(2)}, duration: ${event.metrics.totalLatencyMs}ms)`);
                 setState((prev) => {
                     const newSessions = prev.metrics.sessions + 1;
                     const newAvgDuration = prev.metrics.avgDuration === 0
                         ? event.metrics.totalLatencyMs
                         : Math.round((prev.metrics.avgDuration * prev.metrics.sessions + event.metrics.totalLatencyMs) / newSessions);
+                    const newConfidenceAvg = prev.metrics.confidenceAvg === 0
+                        ? event.metrics.confidence
+                        : (prev.metrics.confidenceAvg * prev.metrics.sessions + event.metrics.confidence) / newSessions;
                     const newSuccessRate = event.metrics.confidence >= 0.7
                         ? Math.round((prev.metrics.successRate * prev.metrics.sessions + 100) / newSessions)
                         : Math.round((prev.metrics.successRate * prev.metrics.sessions) / newSessions);
@@ -153,109 +234,169 @@ export function useAppState() {
                         ...prev,
                         status: "ready",
                         isProcessing: false,
-                        fitness: Math.min(prev.fitness + 0.02, 0.99),
+                        fitness: Math.min(prev.fitness + (event.metrics.confidence * 0.05), 0.99),
                         metrics: {
                             sessions: newSessions,
                             avgDuration: newAvgDuration,
-                            successRate: newSuccessRate,
-                            totalCost: prev.metrics.totalCost + (event.metrics.totalCostUsd || 0),
-                            totalRetries: prev.metrics.totalRetries + (event.metrics.retries || 0),
-                            totalEscalations: prev.metrics.totalEscalations + (event.metrics.escalations || 0),
+                            successRate: Math.min(newSuccessRate, 100),
+                            totalCost: prev.metrics.totalCost + event.metrics.totalCostUsd,
+                            totalRetries: prev.metrics.totalRetries + event.metrics.retries,
+                            totalEscalations: prev.metrics.totalEscalations + event.metrics.escalations,
+                            totalTokens: prev.metrics.totalTokens,
+                            confidenceAvg: newConfidenceAvg,
+                        },
+                        memory: {
+                            nodes: buildMemoryNodes(prev.workflowState),
+                            edges: buildMemoryEdges(prev.workflowState),
+                            nodeCount: prev.workflowState.nodeCount,
+                            cacheHitRate: Math.min(90 + event.metrics.confidence * 10, 98),
                         },
                     };
                 });
                 break;
         }
-    }, []);
-    const addLog = useCallback((log) => {
-        setState((prev) => ({
-            ...prev,
-            logs: [...prev.logs.slice(-100), log],
-        }));
-    }, []);
-    const addMessage = useCallback((type, content, agent, model) => {
-        setState((prev) => ({
-            ...prev,
-            messages: [
-                ...prev.messages,
-                { id: generateId(), type, content, timestamp: new Date(), agent, model: model || prev.model },
-            ],
-        }));
-    }, []);
-    const updateAgentStatus = useCallback((agentName, status) => {
-        setState((prev) => ({
-            ...prev,
-            agents: prev.agents.map((a) => a.name === agentName ? { ...a, status } : a),
-        }));
-    }, []);
-    const updateDAGNode = useCallback((nodeId, status) => {
-        setState((prev) => {
-            const newLevels = prev.workflowState.levels.map((level) => {
-                const newNodes = level.nodes.map((node) => node.id === nodeId ? { ...node, status } : node);
-                const doneCount = newNodes.filter((n) => n.status === "done").length;
-                return {
-                    ...level,
-                    nodes: newNodes,
-                    progress: Math.round((doneCount / newNodes.length) * 100),
-                };
+    }, [addLog]);
+    function buildWorkflowFromGraph(graph) {
+        const levels = [];
+        const processed = new Set();
+        const nodes = graph.nodes;
+        while (processed.size < nodes.length) {
+            const levelNodes = nodes.filter((n) => !processed.has(n.id) && n.dependsOn.every((d) => processed.has(d)));
+            if (levelNodes.length === 0)
+                break;
+            levels.push({
+                name: `L${levels.length + 1}`,
+                progress: 0,
+                nodes: levelNodes.map((n) => ({
+                    id: n.id,
+                    name: n.agent,
+                    status: "pending",
+                    agent: n.agent,
+                })),
             });
-            const totalDone = newLevels.reduce((acc, l) => acc + l.nodes.filter((n) => n.status === "done").length, 0);
-            const totalNodes = newLevels.reduce((acc, l) => acc + l.nodes.length, 0);
+            levelNodes.forEach((n) => processed.add(n.id));
+        }
+        return {
+            levels,
+            currentLevel: -1,
+            totalProgress: 0,
+            graphId: graph.id,
+            nodeCount: nodes.length,
+        };
+    }
+    function updateAgentInList(agents, name, status, confidence) {
+        const existing = agents.find((a) => a.name === name);
+        if (existing) {
+            return agents.map((a) => a.name === name ? { ...a, status, confidence, lastRun: new Date() } : a);
+        }
+        return [...agents, { name, role: name, status, provider: state.provider, confidence }];
+    }
+    function updateNodeStatus(workflow, nodeId, status, confidence) {
+        const now = Date.now();
+        const newLevels = workflow.levels.map((level) => {
+            const newNodes = level.nodes.map((node) => node.id === nodeId
+                ? {
+                    ...node,
+                    status,
+                    confidence,
+                    startTime: status === "running" ? now : node.startTime,
+                    endTime: status === "done" || status === "error" ? now : node.endTime,
+                }
+                : node);
+            const doneCount = newNodes.filter((n) => n.status === "done").length;
             return {
-                ...prev,
-                workflowState: {
-                    levels: newLevels,
-                    currentLevel: newLevels.findIndex((l) => l.nodes.some((n) => n.status === "running")),
-                    totalProgress: Math.round((totalDone / totalNodes) * 100),
-                },
+                ...level,
+                nodes: newNodes,
+                progress: Math.round((doneCount / newNodes.length) * 100),
             };
         });
-    }, []);
+        const totalDone = newLevels.reduce((acc, l) => acc + l.nodes.filter((n) => n.status === "done").length, 0);
+        const totalNodes = newLevels.reduce((acc, l) => acc + l.nodes.length, 0);
+        const currentLevel = newLevels.findIndex((l) => l.nodes.some((n) => n.status === "running"));
+        return {
+            levels: newLevels,
+            currentLevel,
+            totalProgress: totalNodes > 0 ? Math.round((totalDone / totalNodes) * 100) : 0,
+            graphId: workflow.graphId,
+            nodeCount: workflow.nodeCount,
+        };
+    }
+    function incrementProviderRequests(providers, providerName) {
+        return providers.map((p) => p.name === providerName ? { ...p, requests: p.requests + 1 } : p);
+    }
+    function buildMemoryNodes(workflow) {
+        return workflow.levels.flatMap((level) => level.nodes
+            .filter((n) => n.status === "done" && n.agent)
+            .map((n) => ({
+            id: n.id,
+            type: n.agent.toLowerCase().includes("test") ? "test"
+                : n.agent.toLowerCase().includes("fix") ? "fix"
+                    : n.agent.toLowerCase().includes("code") ? "action"
+                        : "task",
+            label: n.name.slice(0, 12),
+            confidence: n.confidence,
+        })));
+    }
+    function buildMemoryEdges(workflow) {
+        const edges = [];
+        for (let i = 0; i < workflow.levels.length - 1; i++) {
+            const currentLevel = workflow.levels[i];
+            const nextLevel = workflow.levels[i + 1];
+            currentLevel.nodes.forEach((node) => {
+                nextLevel.nodes.slice(0, 2).forEach((nextNode) => {
+                    edges.push({ from: node.id, to: nextNode.id });
+                });
+            });
+        }
+        return edges.slice(0, 10);
+    }
     const resetWorkflow = useCallback(() => {
+        nodeTimingsRef.current.clear();
         setState((prev) => ({
             ...prev,
-            workflowState: DEFAULT_WORKFLOW_STATE,
-            agents: DEFAULT_AGENTS.map((a) => ({ ...a, status: "idle" })),
+            workflowState: EMPTY_WORKFLOW_STATE,
+            agents: prev.agents.map((a) => ({ ...a, status: "idle" })),
         }));
     }, []);
     const processCommand = useCallback(async (input) => {
         const trimmed = input.trim().toLowerCase();
         const parts = trimmed.split(" ");
         const command = parts[0];
-        const args = parts.slice(1).join(" ");
         switch (command) {
             case "help":
-                addMessage("system", `Commandes disponibles:
-stop      - Arrêter le workflow en cours
-retry     - Relancer la dernière tâche
-clear     - Nettoyer les messages
-session   - Voir les sessions
-evolve    - Forcer l'évolution du workflow
-theme     - Changer de thème (theme <nom> pour voir la liste)
-toggle    - Basculer entre modes (full/compact/minimal)
-history   - Historique des workflows
-config    - Voir la configuration
-exit      - Quitter
+                addMessage("system", `Available commands:
+stop      - Stop current workflow
+retry     - Retry last task
+clear     - Clear messages
+session   - View sessions
+evolve    - Force workflow evolution
+theme     - Change theme
+providers - List providers
+toggle    - Toggle view mode
+history   - View history
+config    - View configuration
+exit      - Quit
 
-Tout autre texte = lance un workflow avec ce prompt.`);
+Any other text = start workflow with that prompt.`);
                 break;
             case "stop":
                 if (state.isProcessing) {
-                    addMessage("system", "⏹ Workflow arrêté.");
+                    orchestratorRef.current.stop();
+                    addMessage("system", "⏹ Workflow stopped.");
                     setState((prev) => ({ ...prev, status: "ready", isProcessing: false, currentWorkflow: null }));
                     resetWorkflow();
                 }
                 else {
-                    addMessage("system", "Aucun workflow en cours.");
+                    addMessage("system", "No workflow in progress.");
                 }
                 break;
             case "retry":
                 if (state.currentWorkflow) {
-                    addMessage("system", `🔄 Relance du workflow: ${state.currentWorkflow}`);
+                    addMessage("system", `🔄 Retrying workflow: ${state.currentWorkflow}`);
                     runWorkflow(state.currentWorkflow);
                 }
                 else {
-                    addMessage("error", "Aucun workflow à relancer.");
+                    addMessage("error", "No workflow to retry.");
                 }
                 break;
             case "clear":
@@ -264,7 +405,7 @@ Tout autre texte = lance un workflow avec ce prompt.`);
                     messages: [{
                             id: generateId(),
                             type: "system",
-                            content: "Messages nettoyés.",
+                            content: "Messages cleared.",
                             timestamp: new Date(),
                             model: prev.model,
                         }],
@@ -274,20 +415,21 @@ Tout autre texte = lance un workflow avec ce prompt.`);
             case "session":
                 const sessionList = state.sessions.length > 0
                     ? state.sessions.map((s, i) => `${i + 1}. [${s.timestamp.toLocaleTimeString()}] ${s.prompt.slice(0, 30)}... (${s.status})`).join("\n")
-                    : "Aucune session enregistrée.";
+                    : "No sessions recorded.";
                 addMessage("system", `SESSIONS (${state.sessions.length})\n${sessionList}`);
                 break;
+            case "providers":
+                const providerList = state.providers.map((p) => `${p.name}: ${p.status} (${p.latency}ms) - ${p.requests} requests`).join("\n");
+                addMessage("system", `PROVIDERS\n${providerList}`);
+                break;
             case "evolve":
-                const mutations = Math.floor(Math.random() * 3) + 1;
                 const newFitness = Math.min(state.fitness + 0.05, 0.99);
                 setState((prev) => ({ ...prev, fitness: newFitness }));
                 addMessage("system", `EVOLUTION
-Mutations appliquées: +${mutations}
 Fitness: ${state.fitness.toFixed(2)} → ${newFitness.toFixed(2)}
-Tendance: ↗ +${((newFitness - state.fitness) * 100).toFixed(1)}%`);
+Trend: ↗ +${((newFitness - state.fitness) * 100).toFixed(1)}%`);
                 break;
             case "theme":
-                // Show interactive theme selector
                 setState((prev) => ({
                     ...prev,
                     interactiveCommand: {
@@ -312,11 +454,11 @@ Tendance: ↗ +${((newFitness - state.fitness) * 100).toFixed(1)}%`);
                 const currentIndex = modes.indexOf(state.viewMode);
                 const nextMode = modes[(currentIndex + 1) % modes.length];
                 setState((prev) => ({ ...prev, viewMode: nextMode }));
-                addMessage("system", `Mode changé: ${nextMode.toUpperCase()}`);
+                addMessage("system", `View mode: ${nextMode.toUpperCase()}`);
                 break;
             case "history":
-                const historyList = state.sessions.slice(-5).map((s, i) => `${i + 1}. ${s.prompt.slice(0, 40)}... [${s.status}]`).join("\n") || "Aucun historique.";
-                addMessage("system", `HISTORIQUE (derniers 5)\n${historyList}`);
+                const historyList = state.sessions.slice(-5).map((s, i) => `${i + 1}. ${s.prompt.slice(0, 40)}... [${s.status}]`).join("\n") || "No history.";
+                addMessage("system", `HISTORY (last 5)\n${historyList}`);
                 break;
             case "config":
                 addMessage("system", `CONFIGURATION
@@ -326,11 +468,13 @@ Theme: ${state.theme}
 View Mode: ${state.viewMode}
 Fitness: ${state.fitness.toFixed(2)}
 Agents: ${state.agents.length}
-Sessions: ${state.metrics.sessions}`);
+Sessions: ${state.metrics.sessions}
+Tokens: ${state.metrics.totalTokens}
+Cost: $${state.metrics.totalCost.toFixed(4)}`);
                 break;
             case "exit":
             case "quit":
-                addMessage("system", "À bientôt !");
+                addMessage("system", "Goodbye!");
                 break;
             default:
                 runWorkflow(input);
@@ -339,7 +483,7 @@ Sessions: ${state.metrics.sessions}`);
     const runWorkflow = useCallback(async (prompt) => {
         resetWorkflow();
         addMessage("user", prompt);
-        addMessage("agent", "Lancement du workflow...", "Orchestrator", state.model);
+        addMessage("agent", "Starting workflow...", "Orchestrator", state.model);
         const sessionId = generateId();
         setState((prev) => ({
             ...prev,
@@ -350,33 +494,36 @@ Sessions: ${state.metrics.sessions}`);
                     timestamp: new Date(),
                     status: "running",
                     model: prev.model,
-                }]
+                }],
         }));
         const startTime = Date.now();
         try {
-            await orchestratorRef.current.run(prompt);
+            const result = await orchestratorRef.current.run(prompt);
             const duration = Date.now() - startTime;
-            addMessage("success", `Workflow terminé! Fitness: ${(state.fitness + 0.02).toFixed(2)} | Durée: ${(duration / 1000).toFixed(1)}s`, undefined, state.model);
+            addMessage("success", `Workflow completed!\nConfidence: ${result.metrics.confidence.toFixed(2)}\nDuration: ${(duration / 1000).toFixed(1)}s\nCost: $${result.metrics.totalCostUsd.toFixed(4)}`, undefined, state.model);
             setState((prev) => ({
                 ...prev,
-                sessions: prev.sessions.map((s) => s.id === sessionId ? { ...s, status: "completed", duration } : s),
+                sessions: prev.sessions.map((s) => s.id === sessionId
+                    ? { ...s, status: "completed", duration, confidence: result.metrics.confidence }
+                    : s),
             }));
         }
         catch (error) {
-            addMessage("error", `Erreur: ${error instanceof Error ? error.message : String(error)}`);
+            addMessage("error", `Error: ${error instanceof Error ? error.message : String(error)}`);
             setState((prev) => ({
                 ...prev,
                 status: "error",
                 isProcessing: false,
-                sessions: prev.sessions.map((s) => s.id === sessionId ? { ...s, status: "failed", duration: Date.now() - startTime } : s),
+                sessions: prev.sessions.map((s) => s.id === sessionId
+                    ? { ...s, status: "failed", duration: Date.now() - startTime }
+                    : s),
             }));
         }
-    }, [resetWorkflow, addMessage, state.fitness, state.model]);
+    }, [resetWorkflow, addMessage, state.model]);
     const handleInteractiveCommandNavigation = useCallback((direction) => {
         if (!state.interactiveCommand.type)
             return;
         if (direction === "escape") {
-            // Close the interactive command
             setState((prev) => ({
                 ...prev,
                 interactiveCommand: { type: null, options: [], selectedIndex: 0 },