feat: terminal sudo blocking, token tracking, mermaid & consumption UI

- Block sudo/doas commands when not running as root - Add real token counting from API responses - Track and display consumption by provider/day - Add Mermaid diagram rendering in Shell and Studio - Add copy-to-clipboard buttons for code blocks - Support tables in AI message rendering - Update system prompt with context (date, time, root status) 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>
fix(shell,config): terminal font size, AI tools, provider keys
2026-04-26 12:43:15 +02:00 · 2026-04-25 22:03:35 +02:00 · 2026-04-24 22:41:47 +02:00 · 2026-04-24 22:33:49 +02:00 · 2026-04-24 22:28:15 +02:00 · 2026-04-24 22:19:12 +02:00
28 changed files with 3109 additions and 369 deletions
--- a/internal/agent/definitions.go
+++ b/internal/agent/definitions.go
@@ -3,6 +3,7 @@ package agent
 import (
 	"context"
 	"fmt"
+	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
@@ -14,6 +15,13 @@ type TerminalParams struct {
 	Timeout int    `json:"timeout,omitempty" description:"Timeout in seconds (default 60, max 300)"`
 }

+type TerminalResponse struct {
+	Content     string `json:"content"`
+	IsError     bool   `json:"is_error"`
+	SudoBlocked bool   `json:"sudo_blocked,omitempty"`
+	Command     string `json:"command,omitempty"`
+}
+
 func NewTerminalTool() (*ToolDefinition, error) {
 	return NewTool("terminal",
 		"Execute a shell command on the local system and return the output. Use for running builds, tests, git operations, package management, system info, or any CLI task. Commands run in the user's home directory by default. Long-running commands are auto-terminated.",
@@ -22,6 +30,18 @@ func NewTerminalTool() (*ToolDefinition, error) {
 				return TextErrorResponse("command is required"), nil
 			}

+			if os.Geteuid() != 0 {
+				trimmed := strings.TrimSpace(p.Command)
+				lower := strings.ToLower(trimmed)
+				if strings.HasPrefix(lower, "sudo ") || strings.HasPrefix(lower, "doas ") || strings.HasPrefix(lower, "run0 ") || strings.HasPrefix(lower, "pkexec ") {
+					return ToolResponse{
+						Content: fmt.Sprintf("BLOCKED: Command '%s' requires elevated privileges (%s). The current user is not root. Do NOT retry with sudo. Explain to the user that this command needs admin privileges and suggest an alternative, or tell them to run it manually in their terminal.", trimmed, strings.Fields(trimmed)[0]),
+						IsError: true,
+						Meta:    map[string]string{"sudo_blocked": "true", "command": trimmed},
+					}, nil
+				}
+			}
+
 			timeout := time.Duration(p.Timeout) * time.Second
 			if timeout == 0 {
 				timeout = 60 * time.Second
--- a/internal/agent/prompts/studio_system.md
+++ b/internal/agent/prompts/studio_system.md
@@ -2,6 +2,16 @@ Tu es l'assistant IA de **Muyue Studio**, le centre de commandement de l'environ

 Tu es intégré dans Muyue, un gestionnaire d'environnement de développement de bureau. Ton rôle est d'aider l'utilisateur à configurer, gérer et optimiser son environnement dev.

+<critical_rules>
+1. **AGIS, ne décris pas** — Si l'utilisateur demande de faire quelque chose, utilise les outils immédiatement. Ne dis pas "je pourrais faire X" — fais-le.
+2. **SOIS AUTONOME** — Ne pose pas de questions si tu peux chercher, lire, déduire. Essaie plusieurs approches avant de bloquer. Ne t'arrête que pour les erreurs bloquantes réelles (credentials manquants, permissions, etc.).
+3. **SOIS CONCIS** — Max 4 lignes par défaut. Pas de préambule ("Voici...", "Je vais..."), pas de postambule ("N'hésitez pas...", "J'espère que..."). Réponse directe. Un mot quand c'est suffisant.
+4. **GÈRE LES ERREURS** — Si un outil échoue, essaie 2-3 approches alternatives avant de rapporter l'échec. Lis le message d'erreur complet, isole la cause racine.
+5. **NE DEVINE PAS** — Lis les fichiers avant d'éditer. Utilise les outils pour obtenir les informations manquantes (lire, chercher, grep).
+6. **CONFIDENTIALITÉ** — Ne révèle jamais les clés API, mots de passe, tokens ou informations sensibles.
+7. **LANGUE** — Réponds dans la même langue que l'utilisateur.
+</critical_rules>
+
 ## Environnement

 Muyue gère :
@@ -13,32 +23,70 @@ Muyue gère :

 ## Outils disponibles

-Tu as accès à des outils. Utilise-les concrètement, ne décris pas ce que tu ferais — fais-le.
+| Outil | Usage |
+|-------|-------|
+| **terminal** | Exécuter des commandes shell (builds, tests, git, etc.) |
+| **crush_run** | Déléguer une tâche complexe à Crush (édition de fichiers, refactoring, debug) — préfère cet outil pour les tâches multi-fichiers ou l'écriture de code |
+| **read_file** | Lire le contenu d'un fichier |
+| **list_files** | Lister les fichiers d'un répertoire |
+| **search_files** | Chercher des fichiers par motif (glob) |
+| **grep_content** | Chercher du texte dans les fichiers |
+| **get_config** | Lire la configuration Muyue |
+| **set_provider** | Configurer un fournisseur IA |
+| **manage_ssh** | Gérer les connexions SSH |
+| **web_fetch** | Récupérer le contenu d'une URL |

- **terminal** : Exécuter des commandes shell (builds, tests, git, etc.)
- **crush_run** : Déléguer une tâche complexe à l'agent Crush (édition de fichiers, refactoring, debug)
- **read_file** : Lire le contenu d'un fichier
- **list_files** : Lister les fichiers d'un répertoire
- **search_files** : Chercher des fichiers par motif (glob)
- **grep_content** : Chercher du texte dans le contenu des fichiers
- **get_config** : Lire la configuration Muyue
- **set_provider** : Configurer un fournisseur IA
- **manage_ssh** : Gérer les connexions SSH
- **web_fetch** : Récupérer le contenu d'une URL
+<tool_strategy>
+- **Recherche avant action** — Utilise `search_files`, `grep_content`, `read_file` avant de supposer quoi que ce soit sur l'état du système
+- **Délégation intelligente** — Pour les tâches complexes (refactoring, création de fichiers, debug multi-fichiers), utilise `crush_run` au lieu d'enchaîner des commandes terminal
+- **Parallélisme** — Lance plusieurs appels d'outils en parallèle quand les opérations sont indépendantes
+- **Troncature** — Si un résultat d'outil dépasse 2000 caractères, résume les points clés au lieu de tout afficher
+- **Une chose à la fois** — Sauf si les opérations sont indépendantes, exécute séquentiellement
+</tool_strategy>

-## Règles
+<decision_making>
+- Décide par toi-même : cherche, lis, déduis, agis
+- Ne demande confirmation que pour : actions destructrices (suppression, overwrite), plusieurs approches valides avec des trade-offs importants
+- Si bloqué : documente (a) ce que tu as essayé, (b) pourquoi tu es bloqué, (c) l'action minimale requise
+- Ne t'arrête jamais pour : tâche trop grosse (découpe), trop de fichiers (change-les), complexité (gère-la)
+</decision_making>

-1. **AGIS, ne décris pas** — Si l'utilisateur demande de faire quelque chose, utilise les outils pour le faire. Ne dis pas "je pourrais faire X" — fais-le.
-2. **Sois concis** — Pas de préambule, pas de blabla. Réponse directe.
-3. **Une chose à la fois** — N'appelle pas plusieurs outils simultanément sauf si c'est nécessaire.
-4. **Gère les erreurs** — Si un outil échoue, essaie une approche différente avant de le dire à l'utilisateur.
-5. **Ne devine pas** — Si tu n'as pas assez d'informations, utilise les outils pour les obtenir (lire un fichier, chercher, etc.)
-6. **Confidentialité** — Ne révèle jamais les clés API, mots de passe ou informations sensibles dans tes réponses.
-7. **Langue** — Réponds dans la même langue que l'utilisateur.
+<error_recovery>
+1. Lis le message d'erreur complet
+2. Comprends la cause racine
+3. Essaie une approche différente (pas la même)
+4. Cherche du code similaire qui fonctionne
+5. Applique un correctif ciblé
+6. Vérifie que ça marche
+7. Pour chaque erreur, essaie au moins 2-3 stratégies avant de conclure que c'est bloquant
+</error_recovery>

 ## Format des réponses

- Code : utilise des blocs markdown
- Résultats d'outils : résume les points clés, ne colle pas des milliers de lignes
- Erreurs : explique clairement et propose une solution
- Succès : confirme brièvement ce qui a été fait
+- **Code** : blocs markdown avec le langage spécifié
+- **Résultats d'outils** : résume les points clés, max 2000 caractères, ne copie pas des milliers de lignes
+- **Erreurs** : explique clairement la cause et propose une solution concrète
+- **Succès** : confirme brièvement ce qui a été fait (1 ligne)
+- **Multi-fichiers** : liste les fichiers modifiés avec `fichier:ligne` pour les références
+
+## Diagrammes Mermaid
+
+Tu peux utiliser des diagrammes Mermaid pour visualiser des architectures, flux, séquences, etc.
+Utilise un bloc code avec le langage `mermaid` :
+
+```mermaid
+graph TD
+    A[Début] --> B{Décision}
+    B -->|Oui| C[Action]
+    B -->|Non| D[Fin]
+```
+
+Types utiles :
+- `graph TD/LR` — Architecture, flux de données
+- `sequenceDiagram` — Interactions entre composants
+- `flowchart` — Processus et décisions
+- `classDiagram` — Structures de données
+- `erDiagram` — Schémas de base de données
+- `gantt` — Planning et timelines
+
+Utilise Mermaid quand ça apporte de la clarté : architecture complexe, flux multi-étapes, relations entre entités. Ne l'utilise pas pour du texte simple.
--- a/internal/api/chat_engine.go
+++ b/internal/api/chat_engine.go
@@ -21,6 +21,7 @@ type ChatEngine struct {
 	tools      json.RawMessage
 	onChunk    func(map[string]interface{})
 	stream    bool
+	TotalTokens int
 }

 // NewChatEngine creates a new ChatEngine instance.
@@ -71,6 +72,10 @@ func (ce *ChatEngine) RunWithTools(ctx context.Context, messages []orchestrator.
 			return finalContent, allToolCalls, allToolResults, err
 		}

+		if resp.Usage.TotalTokens > 0 {
+			ce.TotalTokens += resp.Usage.TotalTokens
+		}
+
 		choice := resp.Choices[0]
 		content := cleanThinkingTags(choice.Message.Content)

@@ -123,6 +128,11 @@ func (ce *ChatEngine) RunWithTools(ctx context.Context, messages []orchestrator.
 				"content":     result.Content,
 				"is_error":    result.IsError,
 			}
+			if result.Meta != nil {
+				for k, v := range result.Meta {
+					resultData[k] = v
+				}
+			}
 			allToolResults = append(allToolResults, map[string]interface{}{
 				"tool_call_id": tc.ID,
 				"name":        tc.Function.Name,
@@ -149,6 +159,11 @@ func (ce *ChatEngine) RunWithTools(ctx context.Context, messages []orchestrator.
 	return finalContent, allToolCalls, allToolResults, nil
 }

+// ProviderName returns the name of the active provider used by the engine.
+func (ce *ChatEngine) ProviderName() string {
+	return ce.orchestrator.ProviderName()
+}
+
 // RunNonStream executes chat without streaming content to client.
 func (ce *ChatEngine) RunNonStream(ctx context.Context, messages []orchestrator.Message) (string, error) {
 	var finalContent string
@@ -159,6 +174,10 @@ func (ce *ChatEngine) RunNonStream(ctx context.Context, messages []orchestrator.
 			return finalContent, err
 		}

+		if resp.Usage.TotalTokens > 0 {
+			ce.TotalTokens += resp.Usage.TotalTokens
+		}
+
 		choice := resp.Choices[0]
 		content := cleanThinkingTags(choice.Message.Content)

--- a/internal/api/consumption.go
+++ b/internal/api/consumption.go
@@ -0,0 +1,127 @@
+package api
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/muyue/muyue/internal/config"
+)
+
+type consumptionEntry struct {
+	Date    string `json:"date"`
+	Tokens  int    `json:"tokens"`
+	Requests int   `json:"requests"`
+}
+
+type providerConsumption struct {
+	Name     string             `json:"name"`
+	Daily    []consumptionEntry `json:"daily"`
+	Total    int                `json:"total_tokens"`
+	Requests int                `json:"total_requests"`
+}
+
+type consumptionStore struct {
+	mu        sync.Mutex
+	providers map[string]*providerConsumption
+}
+
+func newConsumptionStore() *consumptionStore {
+	cs := &consumptionStore{
+		providers: make(map[string]*providerConsumption),
+	}
+	cs.load()
+	cs.prune()
+	return cs
+}
+
+func (cs *consumptionStore) Record(providerName string, tokens int) {
+	if tokens <= 0 || providerName == "" {
+		return
+	}
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+
+	today := time.Now().UTC().Format("2006-01-02")
+
+	p, ok := cs.providers[providerName]
+	if !ok {
+		p = &providerConsumption{Name: providerName}
+		cs.providers[providerName] = p
+	}
+
+	p.Total += tokens
+	p.Requests++
+
+	if len(p.Daily) > 0 && p.Daily[len(p.Daily)-1].Date == today {
+		p.Daily[len(p.Daily)-1].Tokens += tokens
+		p.Daily[len(p.Daily)-1].Requests++
+	} else {
+		p.Daily = append(p.Daily, consumptionEntry{
+			Date:     today,
+			Tokens:   tokens,
+			Requests: 1,
+		})
+	}
+
+	cs.save()
+}
+
+func (cs *consumptionStore) GetAll() map[string]*providerConsumption {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+
+	result := make(map[string]*providerConsumption)
+	for k, v := range cs.providers {
+		pc := *v
+		daily := make([]consumptionEntry, len(v.Daily))
+		copy(daily, v.Daily)
+		pc.Daily = daily
+		result[k] = &pc
+	}
+	return result
+}
+
+func (cs *consumptionStore) prune() {
+	cutoff := time.Now().UTC().AddDate(0, 0, -7).Format("2006-01-02")
+	for _, p := range cs.providers {
+		filtered := make([]consumptionEntry, 0)
+		for _, d := range p.Daily {
+			if d.Date >= cutoff {
+				filtered = append(filtered, d)
+			}
+		}
+		p.Daily = filtered
+	}
+}
+
+func (cs *consumptionStore) filePath() string {
+	dir, err := config.ConfigDir()
+	if err != nil {
+		return ""
+	}
+	return filepath.Join(dir, "consumption.json")
+}
+
+func (cs *consumptionStore) load() {
+	fp := cs.filePath()
+	if fp == "" {
+		return
+	}
+	data, err := os.ReadFile(fp)
+	if err != nil {
+		return
+	}
+	json.Unmarshal(data, &cs.providers)
+}
+
+func (cs *consumptionStore) save() {
+	fp := cs.filePath()
+	if fp == "" {
+		return
+	}
+	data, _ := json.Marshal(cs.providers)
+	os.WriteFile(fp, data, 0644)
+}
--- a/internal/api/conversation.go
+++ b/internal/api/conversation.go
@@ -32,9 +32,10 @@ type Conversation struct {
 }

 type ConversationStore struct {
-	mu   sync.RWMutex
-	path string
-	conv *Conversation
+	mu         sync.RWMutex
+	path       string
+	conv       *Conversation
+	realTokens int
 }

 type TokenCount struct {
@@ -133,6 +134,7 @@ func (cs *ConversationStore) Clear() {
 	cs.conv.Summary = ""
 	cs.conv.CreatedAt = time.Now().Format(time.RFC3339)
 	cs.conv.UpdatedAt = time.Now().Format(time.RFC3339)
+	cs.realTokens = 0
 	cs.save()
 }

@@ -154,9 +156,22 @@ func (cs *ConversationStore) TrimOld(keepCount int) {
 }

 func (cs *ConversationStore) ApproxTokenCount() int {
+	if cs.realTokens > 0 {
+		return cs.realTokens
+	}
 	return cs.ApproxTokenCountDetailed().total
 }

+// AddRealTokens accumulates actual token counts from the API response.
+func (cs *ConversationStore) AddRealTokens(tokens int) {
+	if tokens <= 0 {
+		return
+	}
+	cs.mu.Lock()
+	cs.realTokens += tokens
+	cs.mu.Unlock()
+}
+
 func (cs *ConversationStore) ApproxTokenCountDetailed() TokenCount {
 	cs.mu.RLock()
 	defer cs.mu.RUnlock()
--- a/internal/api/handlers_chat.go
+++ b/internal/api/handlers_chat.go
@@ -3,9 +3,12 @@ package api
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"net/http"
+	"os"
 	"regexp"
 	"strings"
+	"time"

 	"github.com/muyue/muyue/internal/agent"
 	"github.com/muyue/muyue/internal/orchestrator"
@@ -42,7 +45,14 @@ func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
 		writeError(w, err.Error(), http.StatusServiceUnavailable)
 		return
 	}
-	orb.SetSystemPrompt(agent.StudioSystemPrompt())
+	var studioPrompt strings.Builder
+	studioPrompt.WriteString(agent.StudioSystemPrompt())
+	studioPrompt.WriteString(fmt.Sprintf("\nDate: %s\nHeure: %s\n", time.Now().Format("02/01/2006"), time.Now().Format("15:04:05")))
+	studioPrompt.WriteString(fmt.Sprintf("Root: %t\n", os.Geteuid() == 0))
+	if os.Geteuid() != 0 {
+		studioPrompt.WriteString("⚠️ Session utilisateur standard — les commandes sudo/doas nécessitent une autorisation. N'utilise PAS sudo ou doas sans demander.\n")
+	}
+	orb.SetSystemPrompt(studioPrompt.String())
 	orb.SetTools(s.agentToolsJSON)

 	if body.Stream {
@@ -91,6 +101,9 @@ func (s *Server) handleStreamChat(w http.ResponseWriter, orb *orchestrator.Orche
 		storeContent = string(storeJSON)
 	}
 	s.convStore.Add("assistant", storeContent)
+	s.convStore.AddRealTokens(engine.TotalTokens)
+
+	s.consumption.Record(engine.ProviderName(), engine.TotalTokens)

 	sseWriter.Write(map[string]interface{}{"done": "true"})
 }
@@ -107,6 +120,10 @@ func (s *Server) handleNonStreamChat(w http.ResponseWriter, orb *orchestrator.Or
 	}

 	s.convStore.Add("assistant", finalContent)
+	s.convStore.AddRealTokens(engine.TotalTokens)
+
+	s.consumption.Record(engine.ProviderName(), engine.TotalTokens)
+
 	writeJSON(w, map[string]string{"content": finalContent})
 }

--- a/internal/api/handlers_common.go
+++ b/internal/api/handlers_common.go
@@ -5,7 +5,21 @@ import (
 	"net/http"
 )

-const summarizePrompt = `Résume la conversation suivante de manière concise et structurée. Garde les points clés, les décisions prises, le contexte technique important. Le résumé doit permettre de continuer la conversation sans perte de contexte. Réponds uniquement avec le résumé, sans meta-commentaire.`
+const summarizePrompt = `Résume cette conversation de manière ultra-concise et structurée.
+
+CONSERVE :
+- Les décisions techniques prises et leur rationale
+- Les configurations modifiées (noms exacts, valeurs)
+- Les fichiers/chemins manipulés
+- Les erreurs rencontrées et leurs résolutions
+- Le contexte nécessaire pour continuer
+
+ÉLIMINE :
+- Les échanges de politesse
+- Les tentatives infructueuses (sauf si la solution n'a pas été trouvée)
+- Les sorties d'outils brutes (garde seulement les conclusions)
+
+FORMAT : Markdown structuré avec sections. Max 500 mots. Pas de méta-commentaire.`

 func writeJSON(w http.ResponseWriter, data interface{}) {
 	json.NewEncoder(w).Encode(data)
--- a/internal/api/handlers_config.go
+++ b/internal/api/handlers_config.go
@@ -187,6 +187,8 @@ func (s *Server) handleValidateProvider(w http.ResponseWriter, r *http.Request)
 		switch body.Name {
 		case "minimax":
 			baseURL = "https://api.minimax.io/v1"
+		case "mimo":
+			baseURL = "https://token-plan-ams.xiaomimimo.com/v1"
 		case "openai":
 			baseURL = "https://api.openai.com/v1"
 		case "anthropic":
--- a/internal/api/handlers_info.go
+++ b/internal/api/handlers_info.go
@@ -530,6 +530,44 @@ func (s *Server) handleProvidersQuota(w http.ResponseWriter, r *http.Request) {
 					}
 				}
 			}
+		case "mimo":
+			q.Healthy = p.APIKey != ""
+			if p.APIKey == "" {
+				q.Error = "no API key"
+				results = append(results, q)
+				continue
+			}
+			mimoBase := p.BaseURL
+			if mimoBase == "" {
+				mimoBase = "https://token-plan-ams.xiaomimimo.com/v1"
+			}
+			req, _ := http.NewRequest("GET", strings.TrimRight(mimoBase, "/")+"/models", nil)
+			req.Header.Set("Authorization", "Bearer "+p.APIKey)
+			resp, err := client.Do(req)
+			if err != nil {
+				q.Error = err.Error()
+			} else {
+				body, _ := io.ReadAll(resp.Body)
+				resp.Body.Close()
+				var data map[string]interface{}
+				if json.Unmarshal(body, &data) == nil {
+					if modelList, ok := data["data"].([]interface{}); ok {
+						models := make([]map[string]interface{}, 0)
+						for _, m := range modelList {
+							if mm, ok := m.(map[string]interface{}); ok {
+								id, _ := mm["id"].(string)
+								if id != "" {
+									models = append(models, map[string]interface{}{
+										"model": id,
+									})
+								}
+							}
+						}
+						q.Data = map[string]interface{}{"models": models, "available": len(models)}
+						q.Healthy = true
+					}
+				}
+			}
 		case "claude", "anthropic":
 			// Claude Code n'a pas d'API externe, vérifier l'installation
 			claudePath := "/usr/bin/claude"
@@ -546,6 +584,15 @@ func (s *Server) handleProvidersQuota(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, map[string]interface{}{"providers": results})
 }

+func (s *Server) handleProvidersConsumption(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		writeError(w, "GET only", http.StatusMethodNotAllowed)
+		return
+	}
+	data := s.consumption.GetAll()
+	writeJSON(w, map[string]interface{}{"providers": data})
+}
+
 func (s *Server) handleRecentCommands(w http.ResponseWriter, r *http.Request) {
 	home, _ := os.UserHomeDir()
 	type cmdEntry struct {
--- a/internal/api/handlers_shell_chat.go
+++ b/internal/api/handlers_shell_chat.go
@@ -1,6 +1,7 @@
 package api

 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -8,6 +9,7 @@ import (
 	"os/exec"
 	"runtime"
 	"strings"
+	"time"

 	"github.com/muyue/muyue/internal/agent"
 	"github.com/muyue/muyue/internal/orchestrator"
@@ -51,81 +53,89 @@ func (s *Server) handleShellChat(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	orb.SetSystemPrompt(s.buildShellSystemPromptV2(req))
+	orb.SetSystemPrompt(s.buildShellSystemPrompt(req))
+	orb.SetTools(s.shellAgentToolsJSON)

 	if req.Stream {
-		s.handleShellChatStreamV2(w, orb)
+		s.handleShellChatStream(w, orb)
 	} else {
-		s.handleShellChatNonStreamV2(w, orb)
+		s.handleShellChatNonStream(w, orb)
 	}
 }

-func (s *Server) buildShellSystemPromptV2(_ ShellChatRequest) string {
+func (s *Server) buildShellSystemPrompt(req ShellChatRequest) string {
 	var sb strings.Builder

-	sb.WriteString(`Tu es l'Analyste Système de Muyue. Tu es un expert en administration système et développement.
-Tu aides l'utilisateur à comprendre son système, diagnostiquer des problèmes, et optimiser son environnement.
-
-RÈGLES STRICTES:
- Tu ne peux JAMAIS exécuter de commande ou de code
- Tu ne peux que analyser, expliquer, et proposer des solutions
- Quand tu proposes du code ou des commandes, mets-les dans des blocs de code markdown avec le langage spécifié
- L'utilisateur pourra les copier ou les envoyer directement au terminal depuis les boutons
-
-`)
+	sb.WriteString(shellSystemPromptBase)

 	analysis := LoadSystemAnalysis()
 	if analysis != "" {
-		sb.WriteString("=== ANALYSE SYSTÈME ACTUELLE ===\n")
+		sb.WriteString("<system_context>\n")
 		sb.WriteString(analysis)
-		sb.WriteString("\n=== FIN DE L'ANALYSE ===\n\n")
+		sb.WriteString("\n</system_context>\n\n")
 	}

 	sb.WriteString(fmt.Sprintf("OS: %s/%s\n", runtime.GOOS, runtime.GOARCH))
 	if hostname, err := os.Hostname(); err == nil {
 		sb.WriteString("Hostname: " + hostname + "\n")
 	}
+	if user := os.Getenv("USER"); user != "" {
+		sb.WriteString("User: " + user + "\n")
+	}
+
+	isRoot := os.Geteuid() == 0
+	sb.WriteString(fmt.Sprintf("Root: %t\n", isRoot))
+	if isRoot {
+		sb.WriteString("⚠️ Session en root — toutes les commandes ont les privilèges administrateur.\n")
+	} else {
+		sb.WriteString("⚠️ Session utilisateur standard — les commandes sudo/doas nécessitent une autorisation. N'utilise PAS sudo ou doas sans demander.\n")
+	}
+
+	now := time.Now()
+	sb.WriteString(fmt.Sprintf("Date: %s\nHeure: %s\n", now.Format("02/01/2006"), now.Format("15:04:05")))

 	return sb.String()
 }

-func (s *Server) handleShellChatStreamV2(w http.ResponseWriter, orb *orchestrator.Orchestrator) {
+func (s *Server) handleShellChatStream(w http.ResponseWriter, orb *orchestrator.Orchestrator) {
 	SetupSSEHeaders(w)
 	flusher, canFlush := w.(http.Flusher)
 	sseWriter := NewSSEWriter(w)

-	// Rebuild history into orchestrator
-	history := s.shellConvStore.Get()
-	for _, m := range history[:len(history)-1] { // all except last user msg
-		if m.Role == "system" {
-			continue
+	ctx := context.Background()
+	messages := s.buildShellContextMessages()
+
+	engine := NewChatEngine(orb, s.shellAgentRegistry, s.shellAgentToolsJSON)
+	engine.OnChunk(func(data map[string]interface{}) {
+		if data == nil {
+			return
 		}
-		// Pre-load orchestrator history
-		orb.AppendHistory(orchestrator.Message{Role: m.Role, Content: m.Content})
-	}
-
-	lastUserMsg := history[len(history)-1].Content
-
-	var finalContent string
-	result, err := orb.SendStream(lastUserMsg, func(chunk string) {
-		finalContent = chunk
-		sseWriter.Write(map[string]interface{}{"content": chunk})
+		sseWriter.Write(data)
 		if canFlush {
 			flusher.Flush()
 		}
 	})

+	finalContent, allToolCalls, allToolResults, err := engine.RunWithTools(ctx, messages)
 	if err != nil {
 		sseWriter.Write(map[string]interface{}{"error": err.Error()})
 		return
 	}

-	content := result
-	if content == "" {
-		content = finalContent
+	storeContent := finalContent
+	if len(allToolCalls) > 0 {
+		storeObj := map[string]interface{}{
+			"content":      storeContent,
+			"tool_calls":   allToolCalls,
+			"tool_results": allToolResults,
+		}
+		storeJSON, _ := json.Marshal(storeObj)
+		storeContent = string(storeJSON)
 	}
+	s.shellConvStore.Add("assistant", storeContent)
+	s.shellConvStore.AddRealTokens(engine.TotalTokens)

-	s.shellConvStore.Add("assistant", cleanThinkingTags(content))
+	s.consumption.Record(engine.ProviderName(), engine.TotalTokens)

 	sseWriter.Write(map[string]interface{}{
 		"done":   "true",
@@ -133,30 +143,66 @@ func (s *Server) handleShellChatStreamV2(w http.ResponseWriter, orb *orchestrato
 	})
 }

-func (s *Server) handleShellChatNonStreamV2(w http.ResponseWriter, orb *orchestrator.Orchestrator) {
-	history := s.shellConvStore.Get()
-	for _, m := range history[:len(history)-1] {
-		if m.Role == "system" {
-			continue
-		}
-		orb.AppendHistory(orchestrator.Message{Role: m.Role, Content: m.Content})
-	}
+func (s *Server) handleShellChatNonStream(w http.ResponseWriter, orb *orchestrator.Orchestrator) {
+	ctx := context.Background()
+	messages := s.buildShellContextMessages()

-	lastUserMsg := history[len(history)-1].Content
-
-	result, err := orb.Send(lastUserMsg)
+	engine := NewChatEngine(orb, s.shellAgentRegistry, s.shellAgentToolsJSON)
+	finalContent, err := engine.RunNonStream(ctx, messages)
 	if err != nil {
 		writeError(w, err.Error(), http.StatusInternalServerError)
 		return
 	}

-	s.shellConvStore.Add("assistant", cleanThinkingTags(result))
+	s.shellConvStore.Add("assistant", finalContent)
+	s.shellConvStore.AddRealTokens(engine.TotalTokens)
+
+	s.consumption.Record(engine.ProviderName(), engine.TotalTokens)
+
 	writeJSON(w, map[string]interface{}{
-		"content": result,
+		"content": finalContent,
 		"tokens":  s.shellConvStore.ApproxTokens(),
 	})
 }

+func (s *Server) buildShellContextMessages() []orchestrator.Message {
+	history := s.shellConvStore.Get()
+	start := 0
+	const shellContextWindow = 20
+	if len(history) > shellContextWindow {
+		start = len(history) - shellContextWindow
+	}
+
+	messages := make([]orchestrator.Message, 0, len(history[start:]))
+
+	for _, m := range history[start:] {
+		content := m.Content
+		if m.Role == "assistant" {
+			var parsed struct {
+				Content   string `json:"content"`
+				ToolCalls []struct {
+					ToolCallID string `json:"tool_call_id"`
+					Name       string `json:"name"`
+					Args       string `json:"args"`
+				} `json:"tool_calls"`
+			}
+			if err := json.Unmarshal([]byte(content), &parsed); err == nil && parsed.Content != "" {
+				content = parsed.Content
+			}
+		}
+		role := m.Role
+		if role == "system" {
+			continue
+		}
+		messages = append(messages, orchestrator.Message{
+			Role:    role,
+			Content: content,
+		})
+	}
+
+	return messages
+}
+
 func (s *Server) handleShellChatHistory(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "GET" {
 		writeError(w, "GET only", http.StatusMethodNotAllowed)
@@ -252,15 +298,33 @@ func (s *Server) handleShellAnalyze(w http.ResponseWriter, r *http.Request) {
 	}
 	orb.SetSystemPrompt(agent.StudioSystemPrompt())

-	analysisPrompt := `Tu es un expert en administration système. Analyse les informations suivantes sur le système de l'utilisateur.
-Génère un rapport d'analyse concis et structuré en markdown qui inclut:
-1. Un résumé de l'état du système
-2. Les points d'attention (performance, sécurité, configuration)
-3. Des recommandations spécifiques d'optimisation
-4. Les outils manquants qui pourraient être utiles
-5. L'état du réseau et des connexions
+	analysisPrompt := `Tu es un expert en administration système. Analyse les informations suivantes et génère un rapport structuré en markdown.

-Sois concret et technique. Le rapport sera utilisé comme contexte pour un assistant terminal.
+STRUCTURE REQUISE :
+
+## État du système
+- Résumé en 2-3 phrases de l'état général (OK/Attention/Critique)
+
+## Points d'attention
+Liste les problèmes détectés par priorité :
+- **CRITIQUE** : problèmes de sécurité, espace disque < 10%, mémoire < 10%
+- **ATTENTION** : CPU élevé, services en échec, config non-optimale
+- **INFO** : améliorations possibles, mises à jour disponibles
+
+## Recommandations
+Pour chaque point d'attention, donne UNE commande ou action corrective concrète.
+
+## Outils manquants
+Liste les outils utiles non installés avec la commande d'installation.
+
+## Réseau
+- Interfaces actives, ports en écoute, connectivité
+
+RÈGLES :
+- Pas de blabla générique — sois spécifique à CE système
+- Inclus les valeurs numériques réelles (%, Go, MHz)
+- Max 1500 mots
+- Le rapport sert de contexte persistant pour un assistant terminal

 ` + sysInfo.String()

--- a/internal/api/server.go
+++ b/internal/api/server.go
@@ -13,14 +13,17 @@ import (
 )

 type Server struct {
-	config         *config.MuyueConfig
-	scanResult     *scanner.ScanResult
-	mux            *http.ServeMux
-	convStore      *ConversationStore
-	shellConvStore *ShellConvStore
-	agentRegistry  *agent.Registry
-	agentToolsJSON json.RawMessage
-	workflowEngine *workflow.Engine
+	config              *config.MuyueConfig
+	scanResult          *scanner.ScanResult
+	mux                 *http.ServeMux
+	convStore           *ConversationStore
+	shellConvStore      *ShellConvStore
+	consumption         *consumptionStore
+	agentRegistry       *agent.Registry
+	agentToolsJSON      json.RawMessage
+	shellAgentRegistry  *agent.Registry
+	shellAgentToolsJSON json.RawMessage
+	workflowEngine      *workflow.Engine
 }

 func NewServer(cfg *config.MuyueConfig) *Server {
@@ -48,10 +51,19 @@ func NewServer(cfg *config.MuyueConfig) *Server {
 	s.scanResult = scanner.ScanSystem()
 	s.convStore = NewConversationStore()
 	s.shellConvStore = NewShellConvStore()
+	s.consumption = newConsumptionStore()
 	s.agentRegistry = agent.DefaultRegistry()
 	tools := s.agentRegistry.OpenAITools()
 	toolsJSON, _ := json.Marshal(tools)
 	s.agentToolsJSON = json.RawMessage(toolsJSON)
+
+	s.shellAgentRegistry = agent.NewRegistry()
+	terminalTool, _ := agent.NewTerminalTool()
+	s.shellAgentRegistry.Register(terminalTool)
+	shellTools := s.shellAgentRegistry.OpenAITools()
+	shellToolsJSON, _ := json.Marshal(shellTools)
+	s.shellAgentToolsJSON = json.RawMessage(shellToolsJSON)
+
 	s.workflowEngine, _ = workflow.NewEngine(s.agentRegistry)
 	s.routes()
 	return s
@@ -121,6 +133,7 @@ func (s *Server) routes() {
 	s.mux.HandleFunc("/api/skills/import", s.handleSkillImport)
 	s.mux.HandleFunc("/api/dashboard/status", s.handleDashboardStatus)
 	s.mux.HandleFunc("/api/providers/quota", s.handleProvidersQuota)
+	s.mux.HandleFunc("/api/providers/consumption", s.handleProvidersConsumption)
 	s.mux.HandleFunc("/api/recent-commands", s.handleRecentCommands)
 	s.mux.HandleFunc("/api/running-processes", s.handleRunningProcesses)
 	s.mux.HandleFunc("/api/system/metrics", s.handleSystemMetrics)
--- a/internal/api/shell_conversation.go
+++ b/internal/api/shell_conversation.go
@@ -14,6 +14,63 @@ import (
 const shellMaxTokens = 100000
 const shellCharsPerToken = 4

+const shellSystemPromptBase = `Tu es l'**Analyste Système** de Muyue. Tu es un expert en administration système, DevOps et développement.
+
+<critical_rules>
+1. **AGIS, ne décris pas** — Utilise l'outil terminal pour exécuter, ne te contente pas de proposer des commandes.
+2. **SOIS AUTONOME** — Cherche les infos manquantes via des commandes avant de demander à l'utilisateur. Essaie plusieurs approches avant de bloquer.
+3. **SOIS CONCIS** — Max 4 lignes par défaut. Pas de préambule. Réponse directe et technique.
+4. **GÈRE LES ERREURS** — Si une commande échoue, lis l'erreur, comprends la cause, essaie une approche alternative. 2-3 tentatives avant de rapporter.
+5. **SÉCURITÉ** — Ne révèle jamais de credentials. Demande confirmation avant les commandes destructrices (rm -rf, format, etc.).
+6. **LANGUE** — Réponds dans la même langue que l'utilisateur.
+</critical_rules>
+
+<tool_usage>
+Outil disponible : **terminal** — Exécute des commandes shell sur le système local.
+
+Stratégies :
+- **Diagnostique** — Enchaîne les commandes de diagnostic (ps, df, free, top, journalctl, dmesg, netstat, ss, etc.)
+- **Parallélisme** — Combine les commandes avec && ou ; quand elles sont indépendantes
+- **Filtrage** — Utilise grep, awk, sort, head pour extraire l'essentiel des sorties volumineuses
+- **Non-interactif** — Préfère les commandes non-interactives (apt install -y, non pas apt install)
+- **Troncature** — Si le résultat dépasse 2000 caractères, résume les points clés au lieu de tout afficher
+</tool_usage>
+
+<decision_making>
+- Décide par toi-même : exécute des commandes pour comprendre l'état du système
+- Ne demande confirmation que pour les actions destructrices
+- Si tu ne connais pas la commande exacte, exécute la commande avec --help pour la trouver
+- Si bloqué : documente ce que tu as essayé, pourquoi, et l'action minimale requise
+- Ne t'arrête jamais pour une tâche complexe — découpe en étapes et exécute-les
+</decision_making>
+
+<error_recovery>
+1. Lis le message d'erreur complet (stderr + stdout)
+2. Identifie la cause racine (permissions, paquet manquant, config, service)
+3. Essaie : vérifier le service, vérifier les logs, chercher le paquet, tester la connexion
+4. Propose une solution concrète, pas générique
+</error_recovery>
+
+<response_format>
+- **Commandes** : blocs markdown avec le langage (bash, sh, etc.)
+- **Résultats** : résume les métriques clés, pas de dump complet
+- **Erreurs** : cause + solution en 1-2 lignes
+- **Succès** : confirmation en 1 ligne
+- **Analyses** : markdown structuré avec sections si nécessaire
+</response_format>
+
+<mermaid>
+Tu peux utiliser des diagrammes Mermaid pour visualiser :
+- Architecture système (graph TD/LR)
+- Flux réseau (sequenceDiagram)
+- Processus (flowchart)
+- Timeline (gantt)
+
+Utilise un bloc de code avec le langage mermaid quand ça clarifie l'explication. Pas pour du texte simple.
+</mermaid>
+
+`
+
 type ShellMessage struct {
 	ID      string `json:"id"`
 	Role    string `json:"role"`
@@ -22,9 +79,10 @@ type ShellMessage struct {
 }

 type ShellConvStore struct {
-	mu   sync.RWMutex
-	path string
-	msgs []ShellMessage
+	mu         sync.RWMutex
+	path       string
+	msgs       []ShellMessage
+	realTokens int
 }

 func NewShellConvStore() *ShellConvStore {
@@ -82,19 +140,37 @@ func (s *ShellConvStore) Clear() {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.msgs = []ShellMessage{}
+	s.realTokens = 0
 	s.save()
 }

 func (s *ShellConvStore) ApproxTokens() int {
+	if s.realTokens > 0 {
+		return s.realTokens
+	}
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	total := 0
 	for _, m := range s.msgs {
 		total += utf8.RuneCountInString(m.Content) / shellCharsPerToken
 	}
+	total += utf8.RuneCountInString(shellSystemPromptBase) / shellCharsPerToken
+	if analysis := LoadSystemAnalysis(); analysis != "" {
+		total += utf8.RuneCountInString(analysis) / shellCharsPerToken
+	}
 	return total
 }

+// AddRealTokens accumulates actual token counts from the API response.
+func (s *ShellConvStore) AddRealTokens(tokens int) {
+	if tokens <= 0 {
+		return
+	}
+	s.mu.Lock()
+	s.realTokens += tokens
+	s.mu.Unlock()
+}
+
 func (s *ShellConvStore) AtLimit() bool {
 	return s.ApproxTokens() >= shellMaxTokens
 }
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -128,6 +128,22 @@ var DEFAULT_TERMINAL_THEMES = map[string]TerminalTheme{
 	},
 }

+func migrateProviders(cfg *MuyueConfig) {
+	defaults := Default().AI.Providers
+	for _, dp := range defaults {
+		found := false
+		for _, p := range cfg.AI.Providers {
+			if p.Name == dp.Name {
+				found = true
+				break
+			}
+		}
+		if !found {
+			cfg.AI.Providers = append(cfg.AI.Providers, dp)
+		}
+	}
+}
+
 func GetTerminalTheme(name string) TerminalTheme {
 	if theme, ok := DEFAULT_TERMINAL_THEMES[name]; ok {
 		return theme
@@ -206,6 +222,8 @@ func Load() (*MuyueConfig, error) {
 		}
 	}

+	migrateProviders(&cfg)
+
 	return &cfg, nil
 }

@@ -269,6 +287,12 @@ func Default() *MuyueConfig {
 			BaseURL: "https://api.minimax.io/v1",
 			Active:  true,
 		},
+		{
+			Name:    "mimo",
+			Model:   "mimo-v2.5-pro",
+			BaseURL: "https://token-plan-ams.xiaomimimo.com/v1",
+			Active:  false,
+		},
 		{
 			Name:    "zai",
 			Model:   "glm",
@@ -297,6 +321,7 @@ func Default() *MuyueConfig {

 	cfg.Terminal.CustomPrompt = true
 	cfg.Terminal.PromptTheme = "zerotwo"
+	cfg.Terminal.FontSize = 14

 	return cfg
 }
--- a/internal/orchestrator/orchestrator.go
+++ b/internal/orchestrator/orchestrator.go
@@ -476,6 +476,8 @@ func getProviderBaseURL(name string) string {
 		return "https://api.openai.com/v1"
 	case "zai":
 		return "https://api.z.ai/v1"
+	case "mimo":
+		return "https://token-plan-ams.xiaomimimo.com/v1"
 	default:
 		return ""
 	}
@@ -503,11 +505,19 @@ func (o *Orchestrator) sendWithFallback(reqBody ChatRequest, baseURLOverride str
 	if o.provider != nil {
 		providerOrder = append(providerOrder, o.provider)
 	}
+	var zaiProvider *config.AIProvider
 	for _, p := range providers {
 		if o.provider == nil || p.Name != o.provider.Name {
-			providerOrder = append(providerOrder, p)
+			if p.Name == "zai" {
+				zaiProvider = p
+			} else {
+				providerOrder = append(providerOrder, p)
+			}
 		}
 	}
+	if zaiProvider != nil {
+		providerOrder = append(providerOrder, zaiProvider)
+	}

 	var lastErr error
 	var triedProviders []string
--- a/internal/version/version.go
+++ b/internal/version/version.go
@@ -7,7 +7,7 @@ import (

 const (
 	Name    = "muyue"
-	Version = "0.3.5"
+	Version = "0.4.0"
 	Author  = "La Légion de Muyue"
 )

--- a/internal/workflow/planner.go
+++ b/internal/workflow/planner.go
@@ -159,14 +159,18 @@ func parsePlanResponse(content string) ([]Step, error) {
 	return steps, nil
 }

-const plannerSystemPrompt = `Tu es un assistant de planification de workflows pour Muyue. Tu génères des plans d'exécution sous forme de JSON. Chaque plan est une séquence d'étapes (steps) représentant des appels d'outils.
+const plannerSystemPrompt = `Tu es un planificateur de workflows pour Muyue. Tu génères des plans d'exécution sous forme de tableaux JSON.

-Pour générer un plan:
-1. Comprends l'objectif de l'utilisateur
-2. Identifie les outils nécessaires
-3. Décompose en étapes logiques
-4. Spécifie les paramètres de chaque outil
+RÈGLES :
+1. Analyse l'objectif → identifie les outils → décompose en étapes
+2. Chaque étape : {"name": string, "tool": string, "args": object}
+3. Max 10 étapes par plan
+4. Ordonne par dépendances (les lectures avant les écritures)
+5. Préfère les commandes non-interactives
+6. Utilise crush_run pour les tâches complexes multi-fichiers

-Réponds toujours en JSON valide, sans texte additionnel.`
+Outils : terminal, crush_run, read_file, list_files, search_files, grep_content, get_config, set_provider, manage_ssh, web_fetch

-var _ = plannerSystemPrompt
+Réponds UNIQUEMENT en JSON valide, sans texte avant/après.`
+
+const _ = plannerSystemPrompt
--- a/web/.npmrc
+++ b/web/.npmrc
@@ -0,0 +1 @@
+legacy-peer-deps=true
--- a/web/package-lock.json
+++ b/web/package-lock.json
--- a/web/package.json
+++ b/web/package.json
@@ -9,9 +9,14 @@
  },
  "dependencies": {
    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-image": "^0.10.0-beta.203",
+    "@xterm/addon-search": "^0.17.0-beta.203",
+    "@xterm/addon-unicode11": "^0.10.0-beta.203",
    "@xterm/addon-web-links": "^0.12.0",
-    "@xterm/xterm": "^6.0.0",
+    "@xterm/addon-webgl": "^0.20.0-beta.202",
+    "@xterm/xterm": "^6.1.0-beta.203",
    "lucide-react": "^1.8.0",
+    "mermaid": "^11.14.0",
    "react": "^19.2.5",
    "react-dom": "^19.2.5"
  },
--- a/web/src/api/client.js
+++ b/web/src/api/client.js
@@ -38,6 +38,7 @@ const api = {
  importSkill: (path) => request('/skills/import', { method: 'POST', body: JSON.stringify({ import_path: path }) }),
  getDashboardStatus: () => request('/dashboard/status'),
  getProvidersQuota: () => request('/providers/quota'),
+  getProvidersConsumption: () => request('/providers/consumption'),
  getRecentCommands: () => request('/recent-commands'),
  getRunningProcesses: () => request('/running-processes'),
  getSystemMetrics: () => request('/system/metrics'),
@@ -141,7 +142,11 @@ const api = {
              if (data.error) { reject(new Error(data.error)); return }
              if (data.done) { resolve({ content: full, tokens: data.tokens }); return }
              if (data.content) {
-                full = data.content
+                full += data.content
+                if (onChunk) onChunk(full, data)
+              } else if (data.tool_call || data.tool_result) {
+                if (onChunk) onChunk(full, data)
+              } else if (data.thinking !== undefined || data.thinking_end) {
                if (onChunk) onChunk(full, data)
              }
            } catch {}
--- a/web/src/components/App.jsx
+++ b/web/src/components/App.jsx
@@ -92,6 +92,10 @@ export default function App() {
      { keys: `${layout.keys.shift}+${layout.keys.enter}`, desc: t('statusbar.newLine') },
    ],
    shell: [
+      { keys: `${layout.keys.ctrl}+${layout.keys.shift}+C`, desc: t('statusbar.copy') },
+      { keys: `${layout.keys.ctrl}+${layout.keys.shift}+V`, desc: t('statusbar.paste') },
+      { keys: `${layout.keys.ctrl}+${layout.keys.shift}+F`, desc: t('statusbar.search') },
+      { keys: `${layout.keys.ctrl}++/${layout.keys.ctrl}+−`, desc: t('statusbar.zoom') },
      { keys: layout.keys.enter, desc: t('statusbar.runCommand') },
      { keys: `${layout.keys.up}/${layout.keys.down}`, desc: t('statusbar.commandHistory') },
    ],
--- a/web/src/components/Config.jsx
+++ b/web/src/components/Config.jsx
@@ -1,5 +1,5 @@
 import { useState, useEffect, useCallback } from 'react'
-import { User, Brain, RefreshCw, Wrench, Monitor, AlertTriangle, X } from 'lucide-react'
+import { User, Brain, RefreshCw, Wrench, Monitor, AlertTriangle } from 'lucide-react'
 import { useI18n } from '../i18n'

 const PANELS = [
@@ -101,9 +101,9 @@ export default function Config({ api }) {
      ...prev,
      [p.name]: {
        name: p.name,
-        api_key: p.apiKey || '',
+        api_key: p.api_key || '',
        model: p.model || '',
-        base_url: p.baseURL || '',
+        base_url: p.base_url || '',
      },
    }))
    setEditProvider(p.name)
@@ -311,20 +311,10 @@ function PanelProviders({ providers, editProvider, providerForm, setProviderForm
  const [validating, setValidating] = useState(null)
  const [keyStatus, setKeyStatus] = useState({})

-  useEffect(() => {
-    providers.forEach(p => {
-      if (p.apiKey && !keyStatus[p.name]) {
-        validateKey(p)
-      } else if (!p.apiKey) {
-        setKeyStatus(prev => ({ ...prev, [p.name]: { valid: false, checked: true, error: 'Aucune clé' } }))
-      }
-    })
-  }, [providers])
-
  const validateKey = async (p) => {
    setValidating(p.name)
    try {
-      await api.validateProvider({ name: p.name, api_key: p.apiKey, model: p.model, base_url: p.baseURL || '' })
+      await api.validateProvider({ name: p.name, api_key: p.api_key, model: p.model, base_url: p.base_url || '' })
      setKeyStatus(prev => ({ ...prev, [p.name]: { valid: true, checked: true } }))
    } catch (err) {
      setKeyStatus(prev => ({ ...prev, [p.name]: { valid: false, checked: true, error: err.message || 'Clé invalide' } }))
@@ -332,6 +322,16 @@ function PanelProviders({ providers, editProvider, providerForm, setProviderForm
    setValidating(null)
  }

+  useEffect(() => {
+    providers.forEach(p => {
+      if (p.api_key && !keyStatus[p.name]) {
+        validateKey(p)
+      } else if (!p.api_key) {
+        setKeyStatus(prev => ({ ...prev, [p.name]: { valid: false, checked: true, error: 'Aucune clé' } }))
+      }
+    })
+  }, [providers])
+
  const handleValidate = async (name, apiKey, model, baseUrl) => {
    setValidating(name)
    try {
@@ -343,7 +343,7 @@ function PanelProviders({ providers, editProvider, providerForm, setProviderForm
    setValidating(null)
  }

-  const displayed = providers.filter(p => p.name === 'minimax' || p.name === 'zai')
+  const displayed = providers.filter(p => p.name === 'minimax' || p.name === 'mimo')

  return (
    <div className="config-providers-list">
@@ -370,7 +370,7 @@ function PanelProviders({ providers, editProvider, providerForm, setProviderForm
                  <input
                    className="config-form-input"
                    type="password"
-                    placeholder={p.apiKey ? '••••••••' : t('config.tokenPlaceholder')}
+                    placeholder={p.api_key ? '••••••••' : t('config.tokenPlaceholder')}
                    value={isEditing ? (providerForm[p.name]?.api_key || '') : ''}
                    onChange={e => {
                      if (!isEditing) openProviderEdit(p)
@@ -412,7 +412,7 @@ function PanelUpdates({ updates, tools, checking, updating, needsUpdateCount, in
    window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: `Installe l'outil ${tool} sur mon système. Vérifie d'abord s'il est déjà installé, puis installe-le si nécessaire avec les commandes appropriées.` } }))
  }

-  const missingTools = tools.filter(t => !t.installed)
+  const missingTools = tools.filter(tool => !tool.installed)

  return (
    <>
--- a/web/src/components/Dashboard.jsx
+++ b/web/src/components/Dashboard.jsx
@@ -6,6 +6,12 @@ const MAX_POINTS = 30
 const POLL_INTERVAL = 5000
 const MAX_IDLE_POLLS = 3

+function formatTokens(n) {
+  if (n >= 1000000) return (n / 1000000).toFixed(1) + 'M'
+  if (n >= 1000) return (n / 1000).toFixed(1) + 'K'
+  return String(n)
+}
+
 function MiniGraph({ data, max, color, label, unit }) {
  if (!data || data.length < 2) return <div className="dash-graph-empty">collecting...</div>
  const m = max || Math.max(...data, 1)
@@ -37,13 +43,32 @@ function MiniGraph({ data, max, color, label, unit }) {
  )
 }

+function BarChart({ data, max, color }) {
+  if (!data || data.length === 0) return null
+  const barW = 100 / 7
+  const m = max || Math.max(...data.map(d => d.tokens), 1)
+  return (
+    <svg viewBox="0 0 100 40" className="dash-graph-svg" preserveAspectRatio="none">
+      {data.map((d, i) => {
+        const h = Math.max(1, (d.tokens / m) * 36)
+        const x = i * barW + barW * 0.15
+        const w = barW * 0.7
+        return (
+          <rect key={i} x={x} y={40 - h} width={w} height={h} rx="1.5" fill={color} opacity={0.85} />
+        )
+      })}
+    </svg>
+  )
+}
+
 export default function Dashboard({ api, refreshRef }) {
  const { t } = useI18n()
  const [quota, setQuota] = useState(null)
+  const [consumption, setConsumption] = useState(null)
  const [recentCmds, setRecentCmds] = useState([])
  const [processes, setProcesses] = useState([])
  const [metrics, setMetrics] = useState(null)
-  const [copiedIdx, setCopiedIdx] = useState(-1)
+  const [copiedSet, setCopiedSet] = useState(new Set())
  const cpuRef = useRef([])
  const memRef = useRef([])
  const netRxRef = useRef([])
@@ -51,13 +76,15 @@ export default function Dashboard({ api, refreshRef }) {

  const loadData = useCallback(async () => {
    try {
-      const [quotaData, cmdData, procData, metricsData] = await Promise.all([
+      const [quotaData, consumData, cmdData, procData, metricsData] = await Promise.all([
        api.getProvidersQuota().catch(() => null),
+        api.getProvidersConsumption().catch(() => null),
        api.getRecentCommands().catch(() => ({ commands: [] })),
        api.getRunningProcesses().catch(() => ({ processes: [] })),
        api.getSystemMetrics().catch(() => null),
      ])
      setQuota(quotaData?.providers || [])
+      setConsumption(consumData?.providers || {})
      setRecentCmds(cmdData.commands || [])
      setProcesses(procData.processes || [])
      if (metricsData) {
@@ -91,7 +118,6 @@ export default function Dashboard({ api, refreshRef }) {
  }, [loadData, refreshRef])

  const minimax = (quota || []).find(p => p.name === 'minimax')
-  const zai = (quota || []).find(p => p.name === 'zai')

  const EXCLUDE_CMDS = ['ls', 'cd', 'pwd', 'clear', 'exit', 'history', 'cat', 'echo', 'grep', 'export', 'alias', 'unalias', 'set', 'unset', 'source', '.', 'fg', 'bg', 'jobs', 'wait', 'true', 'false', 'yes', 'sleep', 'date', 'whoami', 'id', 'uname', 'hostname', 'uptime', 'df', 'free', 'top', 'htop', 'nano', 'vi', 'vim', 'less', 'more', 'tail', 'head', 'man', 'info', 'which', 'whereis', 'type', 'command', 'hash', 'builtin', 'help']

@@ -109,6 +135,38 @@ export default function Dashboard({ api, refreshRef }) {
      .map(([cmd, count]) => ({ cmd, count }))
  })()

+  const maxCount = topCmds.length > 0 ? topCmds[0].count : 1
+
+  const copyCmd = (cmd, key) => {
+    navigator.clipboard.writeText(cmd)
+    setCopiedSet(prev => new Set(prev).add(key))
+    setTimeout(() => setCopiedSet(prev => { const next = new Set(prev); next.delete(key); return next }), 1500)
+  }
+
+  const relativeTime = (ts) => {
+    if (!ts) return ''
+    const diff = Math.floor((Date.now() - new Date(ts).getTime()) / 1000)
+    if (diff < 60) return `${diff}s`
+    if (diff < 3600) return `${Math.floor(diff / 60)}m`
+    if (diff < 86400) return `${Math.floor(diff / 3600)}h`
+    return `${Math.floor(diff / 86400)}d`
+  }
+
+  const recentUnique = (() => {
+    const seen = new Set()
+    return recentCmds.filter(c => {
+      if (seen.has(c.cmd)) return false
+      seen.add(c.cmd)
+      return true
+    })
+  })()
+
+  const providerEntries = consumption ? Object.entries(consumption) : []
+  const colors = ['var(--accent)', '#34d399', '#a78bfa', '#f59e0b', '#f472b6']
+  const maxDaily = providerEntries.length > 0
+    ? Math.max(...providerEntries.map(([, p]) => Math.max(...(p.daily || []).map(d => d.tokens), 0)), 1)
+    : 1
+
  return (
    <div className="dash-grid">
      {/* CPU */}
@@ -139,43 +197,36 @@ export default function Dashboard({ api, refreshRef }) {
        <MiniGraph data={netTxRef.current} max={null} color="#f59e0b" label="TX" unit=" KB/s" />
      </div>

-      {/* API Quota */}
+      {/* Consommation */}
      <div className="dash-card">
        <div className="dash-card-head">
-          <span className="dash-label">API Quota</span>
+          <span className="dash-label">Consommation</span>
+          <span className="dash-count">7j</span>
        </div>
-        <div className="dash-quota-list">
-          {minimax && minimax.data?.models?.map((m, i) => (
-            <div key={i} className="dash-quota-row">
-              <span className="dash-quota-name">{String(m.model).replace('MiniMax-', '')}</span>
-              <div className="dash-bar">
-                <div className="dash-bar-fill" style={{ width: `${Math.min(100, (m.used / m.total) * 100)}%` }} />
+        <div className="dash-consumption-list">
+          {providerEntries.length === 0 && (
+            <span className="dash-empty">Aucune donnée</span>
+          )}
+          {providerEntries.map(([name, p], pi) => (
+            <div key={name} className="dash-consumption-provider">
+              <div className="dash-consumption-head">
+                <span className="dash-consumption-name" style={{ color: colors[pi % colors.length] }}>
+                  {name.toUpperCase()}
+                </span>
+                <span className="dash-consumption-total">
+                  {formatTokens(p.total_tokens)} tokens · {p.total_requests} req
+                </span>
+              </div>
+              <BarChart data={p.daily || []} max={maxDaily} color={colors[pi % colors.length]} />
+              <div className="dash-consumption-days">
+                {(p.daily || []).map((d, i) => (
+                  <span key={i} className="dash-consumption-day">
+                    {d.date.slice(5)} <strong>{formatTokens(d.tokens)}</strong>
+                  </span>
+                ))}
              </div>
-              <span className="dash-quota-val">{m.used}/{m.total}</span>
            </div>
          ))}
-          {minimax && minimax.data?.models?.length === 0 && (
-            <div className="dash-quota-row">
-              <span className="dash-quota-name">MiniMax</span>
-              <span className="dash-quota-val" style={{ color: 'var(--text-tertiary)' }}>{minimax.error || 'no data'}</span>
-            </div>
-          )}
-          {zai && zai.data?.models?.map((m, i) => (
-            <div key={i} className="dash-quota-row">
-              <span className="dash-quota-name">{String(m.model)}</span>
-              <div className="dash-bar">
-                <div className="dash-bar-fill" style={{ width: `${Math.min(100, (m.used / m.total) * 100)}%` }} />
-              </div>
-              <span className="dash-quota-val">{m.used}/{m.total}</span>
-            </div>
-          ))}
-          {zai && !zai.data?.models?.length && (
-            <div className="dash-quota-row">
-              <span className="dash-quota-name">Z.AI</span>
-              <span className="dash-quota-val" style={{ color: 'var(--text-tertiary)' }}>{zai.error || 'no data'}</span>
-            </div>
-          )}
-          {!minimax && !zai && <span className="dash-quota-val" style={{ color: 'var(--text-tertiary)' }}>No providers</span>}
        </div>
      </div>

@@ -197,26 +248,34 @@ export default function Dashboard({ api, refreshRef }) {
      </div>

      {/* Recent Commands */}
-      <div className="dash-card">
+      <div className="dash-card dash-cmd-card">
        <div className="dash-card-head">
          <span className="dash-label">Recent Commands</span>
+          <span className="dash-count">{recentUnique.length}</span>
        </div>
        {topCmds.length > 0 && (
-          <div className="dash-cmd-top">
+          <div className="dash-cmd-freq">
+            <span className="dash-cmd-freq-title">Most used</span>
            {topCmds.map((c, i) => (
-              <div key={i} className={'dash-cmd-chip' + (copiedIdx === i ? ' dash-cmd-chip-copied' : '')} onClick={() => { navigator.clipboard.writeText(c.cmd); setCopiedIdx(i); setTimeout(() => setCopiedIdx(-1), 1200); }}>
-                <span className="dash-cmd-chip-name">{copiedIdx === i ? '✓ Copié' : c.cmd}</span>
-                <span className="dash-cmd-chip-count">{c.count}×</span>
+              <div key={i} className="dash-cmd-freq-row" onClick={() => copyCmd(c.cmd, `top-${i}`)} title={c.cmd}>
+                <span className="dash-cmd-freq-name">{copiedSet.has(`top-${i}`) ? '✓ Copié' : c.cmd}</span>
+                <div className="dash-cmd-freq-bar-wrap">
+                  <div className="dash-cmd-freq-bar" style={{ width: `${(c.count / maxCount) * 100}%` }} />
+                </div>
+                <span className="dash-cmd-freq-count">{c.count}×</span>
              </div>
            ))}
          </div>
        )}
        <div className="dash-cmd-list">
-          {recentCmds.length === 0 && <span className="dash-empty">No history</span>}
-          {recentCmds.map((c, i) => (
-            <div key={i} className="dash-cmd-row" title={c.cmd}>
-              <span className="dash-cmd-shell">{c.shell}</span>
-              <span className="dash-cmd-text">{c.cmd.length > 45 ? c.cmd.slice(0, 42) + '...' : c.cmd}</span>
+          {recentUnique.length === 0 && <span className="dash-empty">No history</span>}
+          {recentUnique.map((c, i) => (
+            <div key={i} className="dash-cmd-row" onClick={() => copyCmd(c.cmd, `list-${i}`)} title={c.cmd + ' · click to copy'}>
+              <div className="dash-cmd-left">
+                <span className="dash-cmd-text">{c.cmd.length > 38 ? c.cmd.slice(0, 35) + '...' : c.cmd}</span>
+                <span className="dash-cmd-time">{relativeTime(c.ts)}</span>
+              </div>
+              <span className="dash-cmd-copy">{copiedSet.has(`list-${i}`) ? '✓' : '⎘'}</span>
            </div>
          ))}
        </div>
--- a/web/src/components/Shell.jsx
+++ b/web/src/components/Shell.jsx
--- a/web/src/components/Studio.jsx
+++ b/web/src/components/Studio.jsx
@@ -1,5 +1,8 @@
 import { useState, useRef, useEffect, useCallback, useMemo } from 'react'
 import { useI18n } from '../i18n'
+import mermaid from 'mermaid'
+
+mermaid.initialize({ startOnLoad: false, theme: 'dark', securityLevel: 'loose', fontFamily: 'var(--font-mono)' })

 const RANKS = {
  commandant: { label: 'Commandant', short: 'CDT', color: '#FFD740' },
@@ -64,7 +67,16 @@ function renderContent(text) {
 function formatText(text) {
  let html = text
    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
-  
+
+  html = html.replace(/^(\|.+\|)\n(\|[\s\-:|]+\|)\n((?:\|.+\|\n?)+)/gm, (match, headerRow, sepRow, bodyRows) => {
+    const headers = headerRow.split('|').filter(c => c.trim() !== '').map(c => `<th>${c.trim()}</th>`).join('')
+    const rows = bodyRows.trim().split('\n').map(row => {
+      const cells = row.split('|').filter(c => c.trim() !== '').map(c => `<td>${c.trim()}</td>`).join('')
+      return `<tr>${cells}</tr>`
+    }).join('')
+    return `<table><thead><tr>${headers}</tr></thead><tbody>${rows}</tbody></table>`
+  })
+
  html = html
    .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
    .replace(/`([^`]+)`/g, '<code class="inline-code">$1</code>')
@@ -74,15 +86,15 @@ function formatText(text) {
    .replace(/^\s*[-*] (.+)$/gm, '<div class="msg-bullet">• $1</div>')
    .replace(/^\s*(\d+)[.)] (.+)$/gm, '<div class="msg-step"><span class="msg-step-num">$1</span> $2</div>')
    .replace(/\n/g, '<br/>')
-  
+
  html = html
    .replace(/<br\/>\s*<br\/>/g, '<br/>')
-    .replace(/<br\/>\s*(<h[234]|<div class="msg-)/g, '$1')
-    .replace(/(<\/h[234]|<\/div>)\s*<br\/>/g, '$1')
+    .replace(/<br\/>\s*(<h[234]|<div class="msg-|<table)/g, '$1')
+    .replace(/(<\/h[234]|<\/div>|<\/table>)\s*<br\/>/g, '$1')
    .replace(/\s+on\w+=["'][^"']*["']/gi, '')
    .replace(/javascript:/gi, '')
    .replace(/data:/gi, '')
-  
+
  return html
 }

@@ -168,10 +180,69 @@ function ToolCallBlock({ call, result }) {
  )
 }

+let mermaidIdCounter = 0
+
+function MermaidBlock({ code }) {
+  const ref = useRef(null)
+  const [svg, setSvg] = useState('')
+  const [error, setError] = useState(false)
+
+  useEffect(() => {
+    let cancelled = false
+    const id = `studio-mermaid-${++mermaidIdCounter}`
+    mermaid.render(id, code).then(({ svg }) => {
+      if (!cancelled) setSvg(svg)
+    }).catch(() => {
+      if (!cancelled) setError(true)
+    })
+    return () => { cancelled = true }
+  }, [code])
+
+  if (error) return <pre className="studio-mermaid-error">{code}</pre>
+  if (!svg) return <div className="studio-mermaid-loading">Chargement...</div>
+  return <div className="studio-mermaid-container" ref={ref} dangerouslySetInnerHTML={{ __html: svg }} />
+}
+
+function CodeBlockWithCopy({ part, index, copiedIdx, setCopiedIdx }) {
+  if (part.lang === 'mermaid') {
+    return (
+      <div className="studio-code-block">
+        <div className="studio-code-header">
+          <span className="studio-code-lang">mermaid</span>
+          <button className={`studio-copy-btn ${copiedIdx === index ? 'copied' : ''}`} onClick={() => {
+            navigator.clipboard.writeText(part.content)
+            setCopiedIdx(index)
+            setTimeout(() => setCopiedIdx(null), 1500)
+          }}>
+            {copiedIdx === index ? 'Copie!' : 'Copier'}
+          </button>
+        </div>
+        <MermaidBlock code={part.content} />
+      </div>
+    )
+  }
+  return (
+    <div className="studio-code-block">
+      <div className="studio-code-header">
+        {part.lang && <span className="studio-code-lang">{part.lang}</span>}
+        <button className={`studio-copy-btn ${copiedIdx === index ? 'copied' : ''}`} onClick={() => {
+          navigator.clipboard.writeText(part.content)
+          setCopiedIdx(index)
+          setTimeout(() => setCopiedIdx(null), 1500)
+        }}>
+          {copiedIdx === index ? 'Copie!' : 'Copier'}
+        </button>
+      </div>
+      <pre><code>{part.content}</code></pre>
+    </div>
+  )
+}
+
 function FeedItem({ msg }) {
  const isUser = msg.role === 'user'
  const isSystem = msg.role === 'system'
  const rank = getRank(msg.role)
+  const [copiedIdx, setCopiedIdx] = useState(null)

  const timeStr = msg.time ? new Date(msg.time).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : ''

@@ -197,7 +268,7 @@ function FeedItem({ msg }) {
    )
  }

-  const cleanContent = displayContent.replace(/<think[^>]*>[\s\S]*?<\/think>/gi, '')
+  let cleanContent = displayContent.replace(/<think[^>]*>[\s\S]*?<\/think>/gi, '')

  return (
    <div className={`feed-item ${msg.role}`}>
@@ -226,10 +297,7 @@ function FeedItem({ msg }) {
          <div className="feed-content">
            {renderContent(cleanContent).map((part, i) =>
              part.type === 'code' ? (
-                <div key={i} className="studio-code-block">
-                  {part.lang && <div className="studio-code-lang">{part.lang}</div>}
-                  <pre><code>{part.content}</code></pre>
-                </div>
+                <CodeBlockWithCopy key={i} part={part} index={i} copiedIdx={copiedIdx} setCopiedIdx={setCopiedIdx} />
              ) : (
                <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
              )
@@ -245,6 +313,7 @@ function StreamingItem({ content, thinking, toolCalls }) {
  const rank = RANKS.general
  const cleanContent = content.replace(/<think[^>]*>[\s\S]*?<\/think>/gi, '')
  const hasToolCalls = toolCalls && toolCalls.length > 0
+  const [copiedIdx, setCopiedIdx] = useState(null)

  const renderedContent = useMemo(() => {
    if (!cleanContent) return []
@@ -281,10 +350,7 @@ function StreamingItem({ content, thinking, toolCalls }) {
          <div className="feed-content">
            {renderedContent.map((part, i) =>
              part.type === 'code' ? (
-                <div key={i} className="studio-code-block">
-                  {part.lang && <div className="studio-code-lang">{part.lang}</div>}
-                  <pre><code>{part.content}</code></pre>
-                </div>
+                <CodeBlockWithCopy key={i} part={part} index={i} copiedIdx={copiedIdx} setCopiedIdx={setCopiedIdx} />
              ) : (
                <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
              )
@@ -309,6 +375,7 @@ export default function Studio({ api }) {
  const [tokenInfo, setTokenInfo] = useState({ used: 0, max: 100000, summarizeAt: 80000 })
  const [contextCollapsed, setContextCollapsed] = useState(false)
  const [messagesCollapsed, setMessagesCollapsed] = useState(false)
+  const [sudoModal, setSudoModal] = useState(null)
  const messagesEnd = useRef(null)
  const feedRef = useRef(null)
  const textareaRef = useRef(null)
@@ -404,7 +471,7 @@ export default function Studio({ api }) {
    const text = input.trim()
    setInput('')

-    const isSlashCommand = (t) => /^\/(clear|help|summarize|export|model(?:\s+\S+)?|plan\s+.+)$/.test(t)
+    const isSlashCommand = (t) => /^\/(clear|help|summarize|model(?:\s+\S+)?)$/.test(t)

    if (text.startsWith('/') && !isSlashCommand(text)) {
      setMessages(prev => [...prev, { id: Date.now().toString(), role: 'user', content: text, time: new Date().toISOString() }])
@@ -424,19 +491,8 @@ export default function Studio({ api }) {
        '- `/clear` - Effacer la conversation',
        '- `/summarize` - Résumer la conversation précédente',
        '- `/help` - Afficher cette aide',
-        '- `/plan <objectif>` - Demander un plan structuré',
-        '- `/export` - Exporter la conversation en Markdown',
        '- `/model` - Afficher le provider et modèle actifs',
-        '- `/model change` - Basculer entre MiniMax et ZAI',
-        '',
-        '## Tools disponibles',
-        '- Terminal - Exécuter des commandes',
-        '- read_file - Lire des fichiers',
-        '- list_files - Lister des fichiers',
-        '- search_files - Rechercher des fichiers',
-        '- grep_content - Rechercher dans le contenu',
-        '- get_config - Lire la configuration',
-        '- web_fetch - Récupérer une page web',
+        '- `/model change` - Basculer entre MiniMax et MiMo',
      ].join('\n')
      setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: helpMsg, time: new Date().toISOString() }])
      return
@@ -452,15 +508,15 @@ export default function Studio({ api }) {
        api.getProviders().then(data => {
          const providers = data.providers || []
          const minimax = providers.find(p => p.name.toUpperCase() === 'MINIMAX')
-          const zai = providers.find(p => p.name.toUpperCase() === 'ZAI')
-          if (!minimax || !zai) {
-            setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: 'MiniMax et ZAI doivent être configurés pour utiliser `/model change`.', time: new Date().toISOString() }])
+          const mimo = providers.find(p => p.name.toUpperCase() === 'MIMO')
+          if (!minimax || !mimo) {
+            setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: 'MiniMax et MiMo doivent être configurés pour utiliser `/model change`.', time: new Date().toISOString() }])
            return
          }
          const active = providers.find(p => p.active)
          const activeName = active ? active.name.toUpperCase() : ''
-          const switchTo = activeName === 'MINIMAX' ? 'ZAI' : 'MINIMAX'
-          const target = switchTo === 'MINIMAX' ? minimax : zai
+          const switchTo = activeName === 'MINIMAX' ? 'MIMO' : 'MINIMAX'
+          const target = switchTo === 'MINIMAX' ? minimax : mimo
          api.saveProvider({ name: target.name, active: true }).then(() => {
            setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: `✓ Provider changé: **${target.name}** (${target.model})`, time: new Date().toISOString() }])
          }).catch(() => {
@@ -481,31 +537,6 @@ export default function Studio({ api }) {
      return
    }

-    if (text.startsWith('/plan ')) {
-      const objective = text.slice(6).trim()
-      if (!objective) {
-        setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: 'Usage: `/plan <objectif>`\nEx: `/plan créer un fichier de test`', time: new Date().toISOString() }])
-        return
-      }
-      setInput(`Crée un plan structuré en étapes numérotées pour: ${objective}. Chaque étape devrait avoir une estimation de complexité et de temps.`)
-      handleSend()
-      return
-    }
-
-    if (text === '/export') {
-      api.getChatHistory().then(data => {
-        let markdown = '# Conversation Export\n\n'
-        data.messages?.forEach((msg, i) => {
-          const roleLabel = msg.role === 'user' ? '👤' : (msg.role === 'assistant' ? '🤖' : '⚙️')
-          markdown += `## [${i + 1}] ${roleLabel} ${msg.role}\n${msg.content}\n\n---\n\n`
-        })
-        setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: 'Conversation exportée:\n```markdown\n' + markdown + '```', time: new Date().toISOString() }])
-      }).catch(() => {
-        setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: 'Erreur: impossible d\'exporter la conversation', time: new Date().toISOString() }])
-      })
-      return
-    }
-
    const userMsg = { id: Date.now().toString(), role: 'user', content: text, time: new Date().toISOString() }
    setMessages(prev => [...prev, userMsg])
    setLoading(true)
@@ -532,9 +563,14 @@ export default function Studio({ api }) {
        if (event && event.tool_call) {
          toolCalls = [...toolCalls, { call: event.tool_call, result: null }]
          setStreamToolCalls([...toolCalls])
+          accumulated = ''
+          setStreaming('')
          return
        }
        if (event && event.tool_result) {
+          if (event.tool_result.sudo_blocked) {
+            setSudoModal({ command: event.tool_result.command || event.tool_result.content })
+          }
          const idx = toolCalls.findIndex(tc => tc.call && tc.call.tool_call_id === event.tool_result.tool_call_id)
          if (idx >= 0) {
            toolCalls[idx] = { ...toolCalls[idx], result: event.tool_result }
@@ -558,6 +594,11 @@ export default function Studio({ api }) {
        aiMsg.content = JSON.stringify({
          content: finalContent,
          tool_calls: toolCalls.map(tc => tc.call),
+          tool_results: toolCalls.map(tc => ({
+            tool_call_id: tc.call?.tool_call_id,
+            result: tc.result?.content || '',
+            is_error: tc.result?.is_error || false,
+          })),
        })
      }
      setMessages(prev => [...prev, aiMsg])
@@ -595,7 +636,7 @@ export default function Studio({ api }) {
    }
  }, [])

-  const COMMANDS = ['/clear', '/summarize', '/help', '/plan', '/export', '/model', '/model change']
+  const COMMANDS = ['/clear', '/summarize', '/help', '/model', '/model change']

  const handleKeyDown = (e) => {
    if (e.key === 'Enter' && !e.shiftKey) {
@@ -737,9 +778,25 @@ export default function Studio({ api }) {
          )}
        </div>
        <div className="studio-input-hint">
-          {t('studio.inputHint')} · /clear /summarize /help /plan /export /model /model change
+          {t('studio.inputHint')} · /clear /summarize /help /model
        </div>
      </div>
+
+      {sudoModal && (
+        <div className="shell-modal-overlay" onClick={() => setSudoModal(null)}>
+          <div className="shell-modal" onClick={e => e.stopPropagation()}>
+            <div className="shell-modal-header">Commande bloquée</div>
+            <div className="shell-modal-body">
+              <p style={{ color: 'var(--accent-bright)', fontWeight: 600, marginBottom: 8 }}>L'IA a tenté d'exécuter une commande nécessitant des privilèges administrateur :</p>
+              <pre style={{ background: 'var(--bg)', padding: '10px 12px', borderRadius: 'var(--radius)', fontSize: 12, overflow: 'auto', fontFamily: 'var(--font-mono)' }}>{sudoModal.command}</pre>
+              <p style={{ color: 'var(--text-secondary)', fontSize: 12, marginTop: 12 }}>La commande a été bloquée. L'IA en a été informée et cherchera une alternative.</p>
+            </div>
+            <div className="shell-modal-footer">
+              <button className="primary" onClick={() => setSudoModal(null)}>Compris</button>
+            </div>
+          </div>
+        </div>
+      )}
    </div>
  )
 }
--- a/web/src/i18n/en.js
+++ b/web/src/i18n/en.js
@@ -16,6 +16,12 @@ const en = {
    switchWindow: 'Switch window',
    sendMessage: 'Send message',
    newLine: 'New line',
+    copy: 'Copy',
+    paste: 'Paste',
+    search: 'Search',
+    zoom: 'Zoom +/−',
+    switchTab: 'Switch tab',
+    nextTab: 'Next tab',
    runCommand: 'Run command',
    commandHistory: 'Command history',
  },
--- a/web/src/i18n/fr.js
+++ b/web/src/i18n/fr.js
@@ -16,6 +16,12 @@ const fr = {
    switchWindow: 'Changer de fen\u00eatre',
    sendMessage: 'Envoyer le message',
    newLine: 'Nouvelle ligne',
+    copy: 'Copier',
+    paste: 'Coller',
+    search: 'Rechercher',
+    zoom: 'Zoom +/\u2212',
+    switchTab: 'Changer d\u2019onglet',
+    nextTab: 'Onglet suivant',
    runCommand: 'Ex\u00e9cuter',
    commandHistory: 'Historique',
  },
--- a/web/src/styles/global.css
+++ b/web/src/styles/global.css
@@ -155,7 +155,7 @@ input::placeholder { color: var(--text-disabled); }
 .header-clock { font-family: var(--font-mono); font-size: 12px; color: var(--accent); font-weight: 600; }

 .content { flex: 1; overflow: hidden; position: relative; }
-.content > div { height: 100%; }
+.content > div { position: absolute; inset: 0; overflow: hidden; }
 .tab-hidden { display: none; }

 .statusbar {
@@ -276,8 +276,8 @@ input::placeholder { color: var(--text-disabled); }
 .sidebar-tab:hover { background: var(--bg-card); color: var(--text-primary); }
 .sidebar-tab.active { background: var(--accent); color: #fff; font-weight: 600; }

-.shell-layout { display: flex; height: 100%; }
-.shell-terminal-col { flex: 1; display: flex; flex-direction: column; min-width: 0; min-height: 0; overflow: hidden; }
+.shell-layout { display: flex; height: 100%; overflow: hidden; }
+.shell-terminal-col { flex: 1; display: flex; flex-direction: column; min-width: 0; overflow: hidden; }

 .shell-tabs-bar {
  display: flex; align-items: center; background: var(--bg-surface);
@@ -329,6 +329,14 @@ input::placeholder { color: var(--text-disabled); }

 .shell-tab-actions { display: flex; align-items: center; gap: 4px; flex-shrink: 0; }

+.shell-zoom-badge {
+  font-size: 10px; font-family: var(--font-mono); font-weight: 600;
+  color: var(--accent); background: var(--accent-bg);
+  padding: 2px 6px; border-radius: 3px;
+  border: 1px solid var(--accent-dim);
+  white-space: nowrap;
+}
+
 .shell-new-tab-wrapper { position: relative; }
 .shell-new-tab-btn {
  display: flex; align-items: center; gap: 2px;
@@ -382,12 +390,48 @@ input::placeholder { color: var(--text-disabled); }
 }
 .shell-menu-divider { height: 1px; background: var(--border); margin: 4px 6px; }

-.shell-xterm-wrapper { flex: 1; background: var(--bg); overflow: hidden; position: relative; }
-.shell-xterm-instance {
-  position: absolute; inset: 0; padding: 4px;
-  display: block !important;
+.shell-xterm-wrapper { flex: 1; min-height: 0; background: var(--bg); overflow: hidden; position: relative; }
+
+.shell-search-bar {
+  position: absolute; top: 8px; right: 12px; z-index: 20;
+  display: flex; align-items: center; gap: 4px;
+  background: var(--bg-elevated); border: 1px solid var(--border);
+  border-radius: var(--radius); padding: 4px 6px;
+  box-shadow: 0 4px 16px rgba(0,0,0,0.4);
 }
-.shell-xterm-instance .xterm { height: 100%; padding: 4px; }
+.shell-search-icon { color: var(--text-tertiary); flex-shrink: 0; }
+.shell-search-input {
+  width: 200px; font-size: 12px; padding: 3px 6px; border-radius: 4px;
+  background: var(--bg-input); color: var(--text-primary); border: 1px solid var(--border);
+  font-family: var(--font-mono); outline: none;
+}
+.shell-search-input:focus { border-color: var(--accent); }
+.shell-search-nav {
+  display: flex; align-items: center; justify-content: center;
+  width: 24px; height: 24px; border-radius: 4px;
+  background: transparent; border: 1px solid var(--border);
+  color: var(--text-tertiary); cursor: pointer; font-size: 12px;
+  padding: 0; transition: all 0.1s;
+}
+.shell-search-nav:hover { background: var(--bg-hover); color: var(--text-primary); border-color: var(--accent-dark); }
+.shell-search-close {
+  display: flex; align-items: center; justify-content: center;
+  width: 24px; height: 24px; border-radius: 4px;
+  background: transparent; border: none;
+  color: var(--text-disabled); cursor: pointer; padding: 0;
+}
+.shell-search-close:hover { color: var(--accent); }
+.shell-xterm-instance {
+  position: absolute;
+  inset: 0;
+  visibility: hidden;
+  pointer-events: none;
+}
+.shell-xterm-instance.active {
+  visibility: visible;
+  pointer-events: auto;
+}
+.shell-xterm-instance .xterm { height: 100%; }

 .connection-dot { width: 8px; height: 8px; border-radius: 50%; display: inline-block; flex-shrink: 0; }
 .connection-dot.on { background: var(--success); box-shadow: 0 0 6px var(--success); }
@@ -396,7 +440,7 @@ input::placeholder { color: var(--text-disabled); }
 .shell-tab.ai-tab .shell-tab-name { color: var(--accent); }
 .shell-tab.ai-tab { border-bottom-color: var(--accent); }

-.shell-ai-col { width: 320px; border-left: 1px solid var(--border); background: var(--bg-surface); display: flex; flex-direction: column; flex-shrink: 0; }
+.shell-ai-col { width: 320px; max-width: 320px; border-left: 1px solid var(--border); background: var(--bg-surface); display: flex; flex-direction: column; flex-shrink: 0; overflow: hidden; }
 .ai-panel-header { padding: 12px 16px; border-bottom: 1px solid var(--border); font-weight: 700; font-size: 13px; color: var(--accent); display: flex; align-items: center; justify-content: space-between; }
 .shell-analyze-btn {
  display: flex; align-items: center; gap: 4px;
@@ -414,6 +458,8 @@ input::placeholder { color: var(--text-disabled); }
 .shell-ai-token-text { font-size: 10px; font-family: var(--font-mono); color: var(--text-tertiary); white-space: nowrap; }
 .ai-panel-messages { flex: 1; overflow-y: auto; padding: 12px; display: flex; flex-direction: column; gap: 8px; }
 .ai-message { padding: 8px 12px; border-radius: var(--radius); font-size: 13px; line-height: 1.5; word-break: break-word; }
+.ai-message.user { background: var(--bg-elevated); border-left: 3px solid var(--accent-bright); color: var(--text-primary); }
+.ai-message.user.analysis { border-left-color: var(--info); background: color-mix(in srgb, var(--info) 8%, var(--bg-elevated)); }
 .ai-message.assistant { background: var(--bg-card); border-left: 3px solid var(--accent); }
 .ai-message.system { background: var(--bg-elevated); border-left: 3px solid var(--info); font-style: italic; color: var(--text-tertiary); font-size: 12px; }
 .ai-message.assistant { background: var(--bg-card); border-left: 3px solid var(--accent); }
@@ -448,6 +494,23 @@ input::placeholder { color: var(--text-disabled); }
 }
 .shell-code-actions button:last-child { border-right: none; }
 .shell-code-actions button:hover { background: var(--accent-bg); color: var(--accent); }
+.shell-code-actions button.copied { background: var(--accent-bg); color: var(--accent); animation: copy-flash 0.3s ease; }
+
+.shell-mermaid-container { padding: 12px; background: var(--bg); overflow-x: auto; display: flex; justify-content: center; }
+.shell-mermaid-container svg { max-width: 100%; height: auto; }
+.shell-mermaid-loading { padding: 16px; text-align: center; color: var(--text-tertiary); font-size: 12px; }
+.shell-mermaid-error { padding: 10px 12px; color: var(--accent-bright); font-family: var(--font-mono); font-size: 12px; white-space: pre-wrap; }
+
+.ai-message table { width: 100%; border-collapse: collapse; margin: 6px 0; font-size: 12px; }
+.ai-message th { background: var(--bg-surface); padding: 6px 10px; text-align: left; font-weight: 600; border: 1px solid var(--border); color: var(--text-secondary); }
+.ai-message td { padding: 5px 10px; border: 1px solid var(--border); color: var(--text-primary); }
+.ai-message tr:nth-child(even) td { background: var(--bg-surface); }
+
+@keyframes copy-flash {
+  0% { transform: scale(1); }
+  50% { transform: scale(1.05); background: color-mix(in srgb, var(--accent) 20%, transparent); }
+  100% { transform: scale(1); }
+}

 .shell-analysis-modal {
  background: var(--bg-elevated); border: 1px solid var(--border);
@@ -676,6 +739,25 @@ input::placeholder { color: var(--text-disabled); }
  white-space: nowrap;
 }

+/* Consumption */
+.dash-consumption-list { display: flex; flex-direction: column; gap: 10px; max-height: 270px; overflow-y: auto; }
+.dash-consumption-provider { display: flex; flex-direction: column; gap: 4px; }
+.dash-consumption-head { display: flex; align-items: center; justify-content: space-between; }
+.dash-consumption-name {
+  font-size: 11px; font-weight: 700; letter-spacing: 0.5px;
+}
+.dash-consumption-total {
+  font-size: 10px; font-family: var(--font-mono); color: var(--text-tertiary);
+}
+.dash-consumption-days {
+  display: flex; gap: 4px; flex-wrap: wrap;
+}
+.dash-consumption-day {
+  font-size: 9px; font-family: var(--font-mono); color: var(--text-tertiary);
+  background: var(--bg-input); padding: 1px 5px; border-radius: 4px;
+}
+.dash-consumption-day strong { color: var(--text-secondary); }
+
 /* Processes */
 .dash-proc-list { display: flex; flex-direction: column; gap: 4px; max-height: 270px; overflow-y: auto; }
 .dash-proc-row {
@@ -691,34 +773,38 @@ input::placeholder { color: var(--text-disabled); }
 }

 /* Commands */
-.dash-cmd-list { display: flex; flex-direction: column; gap: 3px; max-height: 270px; overflow-y: auto; }
+.dash-cmd-card .dash-cmd-list { max-height: 220px; }
+.dash-cmd-list { display: flex; flex-direction: column; gap: 2px; overflow-y: auto; }
 .dash-cmd-row {
-  display: flex; align-items: center; gap: 6px;
-  padding: 3px 0; overflow: hidden;
-}
-.dash-cmd-shell {
-  font-size: 9px; font-family: var(--font-mono); color: var(--text-disabled);
-  background: var(--bg-input); padding: 1px 4px; border-radius: 3px;
-  text-transform: uppercase; flex-shrink: 0;
+  display: flex; align-items: center; justify-content: space-between; gap: 8px;
+  padding: 5px 8px; border-radius: var(--radius-sm);
+  background: var(--bg-surface); cursor: pointer;
+  transition: background 0.12s;
 }
+.dash-cmd-row:hover { background: var(--accent-bg); }
+.dash-cmd-left { display: flex; flex-direction: column; gap: 2px; flex: 1; min-width: 0; }
 .dash-cmd-text {
-  font-size: 11px; font-family: var(--font-mono); color: var(--text-secondary);
+  font-size: 11px; font-family: var(--font-mono); color: var(--text-primary);
  white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
-  flex: 1; min-width: 0;
 }
+.dash-cmd-time { font-size: 9px; color: var(--text-disabled); }
+.dash-cmd-copy { font-size: 13px; color: var(--text-disabled); flex-shrink: 0; }
+.dash-cmd-row:hover .dash-cmd-copy { color: var(--accent); }
+
+.dash-cmd-freq { display: flex; flex-direction: column; gap: 6px; margin-bottom: 10px; padding-bottom: 10px; border-bottom: 1px solid var(--border); }
+.dash-cmd-freq-title { font-size: 10px; font-weight: 700; text-transform: uppercase; color: var(--text-disabled); letter-spacing: 0.05em; margin-bottom: 2px; }
+.dash-cmd-freq-row {
+  display: flex; align-items: center; gap: 8px; cursor: pointer;
+  padding: 3px 4px; border-radius: var(--radius-sm);
+  transition: background 0.12s;
+}
+.dash-cmd-freq-row:hover { background: var(--accent-bg); }
+.dash-cmd-freq-name { font-size: 12px; font-weight: 600; font-family: var(--font-mono); color: var(--text-primary); width: 100px; flex-shrink: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.dash-cmd-freq-bar-wrap { flex: 1; height: 6px; background: var(--bg-input); border-radius: 3px; overflow: hidden; }
+.dash-cmd-freq-bar { height: 100%; background: var(--accent); border-radius: 3px; transition: width 0.3s ease; }
+.dash-cmd-freq-count { font-size: 10px; font-family: var(--font-mono); color: var(--accent); width: 28px; text-align: right; flex-shrink: 0; }

 .dash-cmd-top { display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 8px; }
-.dash-cmd-chip {
-  display: flex; align-items: center; gap: 6px;
-  padding: 6px 12px; border-radius: var(--radius);
-  background: var(--bg-surface); border: 1px solid var(--border);
-  cursor: pointer; transition: all 0.15s;
-}
-.dash-cmd-chip:hover { border-color: var(--accent-dim); background: var(--accent-bg); }
-.dash-cmd-chip-copied { border-color: var(--accent) !important; background: var(--accent-bg) !important; }
-.dash-cmd-chip-copied .dash-cmd-chip-name { color: var(--accent); }
-.dash-cmd-chip-name { font-size: 13px; font-weight: 700; font-family: var(--font-mono); color: var(--text-primary); }
-.dash-cmd-chip-count { font-size: 10px; font-family: var(--font-mono); color: var(--accent); }

 /* Services */
 .dash-services { display: flex; flex-direction: column; gap: 6px; }
@@ -885,11 +971,33 @@ input::placeholder { color: var(--text-disabled); }
  background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius);
  overflow: hidden; margin: 8px 0;
 }
+.studio-code-header {
+  display: flex; align-items: center; justify-content: space-between;
+  background: var(--bg-surface); border-bottom: 1px solid var(--border);
+}
 .studio-code-block pre { padding: 12px 16px; font-family: var(--font-mono); font-size: 13px; line-height: 1.5; overflow-x: auto; color: var(--text-primary); margin: 0; }
 .studio-code-lang {
  padding: 4px 12px; font-size: 11px; font-weight: 600; color: var(--text-tertiary);
-  background: var(--bg-surface); border-bottom: 1px solid var(--border); text-transform: uppercase; letter-spacing: 0.5px;
+  background: var(--bg-surface); text-transform: uppercase; letter-spacing: 0.5px;
 }
+.studio-copy-btn {
+  padding: 3px 10px; font-size: 10px; font-weight: 600; color: var(--text-tertiary);
+  background: transparent; border: none; border-left: 1px solid var(--border);
+  cursor: pointer; transition: all 0.15s; font-family: var(--font-sans);
+  white-space: nowrap;
+}
+.studio-copy-btn:hover { background: var(--accent-bg); color: var(--accent); }
+.studio-copy-btn.copied { background: var(--accent-bg); color: var(--accent); }
+
+.studio-mermaid-container { padding: 12px; background: var(--bg); overflow-x: auto; display: flex; justify-content: center; }
+.studio-mermaid-container svg { max-width: 100%; height: auto; }
+.studio-mermaid-loading { padding: 12px; text-align: center; color: var(--text-tertiary); font-size: 12px; }
+.studio-mermaid-error { padding: 10px 12px; color: var(--accent-bright); font-family: var(--font-mono); font-size: 12px; white-space: pre-wrap; }
+
+.feed-content table { width: 100%; border-collapse: collapse; margin: 8px 0; font-size: 13px; }
+.feed-content th { background: var(--bg-surface); padding: 6px 12px; text-align: left; font-weight: 600; border: 1px solid var(--border); color: var(--text-secondary); }
+.feed-content td { padding: 5px 12px; border: 1px solid var(--border); color: var(--text-primary); }
+.feed-content tr:nth-child(even) td { background: var(--bg-surface); }
 .inline-code { background: var(--bg-input); padding: 2px 6px; border-radius: 4px; font-family: var(--font-mono); font-size: 13px; color: var(--accent-muted); }
 .msg-h3 { font-size: 16px; font-weight: 700; color: var(--text-primary); margin: 10px 0 4px; display: block; }
 .msg-h4 { font-size: 14px; font-weight: 700; color: var(--text-secondary); margin: 8px 0 3px; display: block; }
@@ -1048,3 +1156,76 @@ input::placeholder { color: var(--text-disabled); }
  word-break: break-word;
  background: var(--bg);
 }
+
+/* === XTerm Custom Styling === */
+/* Styles for xterm.js integrated with Muyue theme */
+.shell-xterm-instance .xterm {
+  padding: 4px 8px;
+}
+
+.shell-xterm-instance .xterm-viewport {
+  background-color: var(--bg-base) !important;
+}
+
+.shell-xterm-instance .xterm-screen {
+  background-color: var(--bg-base);
+}
+
+/* Scrollbar styling for xterm */
+.shell-xterm-instance .xterm-viewport::-webkit-scrollbar {
+  width: 8px;
+}
+
+.shell-xterm-instance .xterm-viewport::-webkit-scrollbar-track {
+  background: var(--bg-surface);
+}
+
+.shell-xterm-instance .xterm-viewport::-webkit-scrollbar-thumb {
+  background: var(--accent-dim);
+  border-radius: 4px;
+}
+
+.shell-xterm-instance .xterm-viewport::-webkit-scrollbar-thumb:hover {
+  background: var(--accent-dark);
+}
+
+/* Selection styling */
+.shell-xterm-instance .xterm-selection {
+  background: var(--accent-dim) !important;
+}
+
+/* Focus ring styling */
+.shell-xterm-instance .xterm:focus .xterm-helper-text-container {
+  box-shadow: none;
+}
+
+/* Ensure consistent font rendering */
+.shell-xterm-instance .xterm .xterm-char-measure-element {
+  font-family: var(--font-mono) !important;
+}
+
+/* Bell animation styling */
+.shell-xterm-instance .xterm-bell {
+  animation: xterm-bell-flash 0.3s ease-out;
+}
+
+@keyframes xterm-bell-flash {
+  0% { opacity: 1; }
+  50% { opacity: 0.5; }
+  100% { opacity: 0; }
+}
+
+/* Cursor styling */
+.shell-xterm-instance .xterm-cursor {
+  outline: none !important;
+}
+
+/* Link styling for web links addon */
+.shell-xterm-instance .xterm-link {
+  color: var(--accent-light) !important;
+  text-decoration: underline;
+}
+
+.shell-xterm-instance .xterm-link:hover {
+  color: var(--accent-muted) !important;
+}
Author	SHA1	Message	Date
Augustin	cb3d35756a	feat: terminal sudo blocking, token tracking, mermaid & consumption UI All checks were successful Beta Release / beta (push) Successful in 1m3s Details - Block sudo/doas commands when not running as root - Add real token counting from API responses - Track and display consumption by provider/day - Add Mermaid diagram rendering in Shell and Studio - Add copy-to-clipboard buttons for code blocks - Support tables in AI message rendering - Update system prompt with context (date, time, root status) 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-26 12:43:15 +02:00
Augustin	0830e64ae6	fix(shell,config): terminal font size, AI tools, provider keys All checks were successful Beta Release / beta (push) Successful in 56s Details - Fix terminal default fontSize from 6px to 14px across all references - Add terminal tool to shell AI via ChatEngine with tool_call streaming - Fix provider key detection (apiKey → api_key, baseURL → base_url) - Add mimo provider migration and validation endpoint - Bump version to 0.4.0 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-25 22:03:35 +02:00
Augustin	9a218b1904	fix(shell): set default terminal fontSize to 6px All checks were successful Beta Release / beta (push) Successful in 49s Details All fallbacks were still using 12px. User confirmed 6px is the correct baseline on their display. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 22:41:47 +02:00
Augustin	399b845e14	fix(shell): default fontSize 10px and init new tabs immediately All checks were successful Beta Release / beta (push) Successful in 48s Details - Base font size reduced from 12px to 10px - New tabs now initialize directly when added (was waiting for tab switch because the MutationObserver only fired on visibility changes, not on tab additions) - Zoom level applied to newly created terminals 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 22:33:49 +02:00
Augustin	436d5c6149	feat(shell): add Ctrl+/- zoom and display all shortcuts in footer All checks were successful Beta Release / beta (push) Successful in 48s Details - Ctrl+/Ctrl-/Ctrl+0 to zoom in/out/reset terminal font size - Zoom badge indicator in tab bar - All shell shortcuts now shown in statusbar footer - Added i18n labels for search, zoom, switch tab, next tab 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 22:28:15 +02:00
Augustin	5a9edc076e	fix(deps): upgrade @xterm/xterm to 6.1.0-beta.203 for addon compatibility All checks were successful Beta Release / beta (push) Successful in 49s Details The addon-web-links registerApcHandler API requires xterm >= 6.1.0. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 22:19:12 +02:00
Augustin	5bdc7a6429	fix(shell): enable allowProposedApi for Unicode11 addon All checks were successful Beta Release / beta (push) Successful in 48s Details 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 22:16:23 +02:00
Augustin	5a0480bae0	fix(ci): add .npmrc with legacy-peer-deps for xterm addon resolution All checks were successful Beta Release / beta (push) Successful in 49s Details 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 22:12:05 +02:00
Augustin	80de4dd523	feat(shell): integrate Hyper-like terminal technologies (WebGL, search, unicode11, image) Some checks failed Beta Release / beta (push) Failing after 20s Details Add xterm addons from Vercel Hyper terminal: WebGL renderer with DOM fallback, search bar (Ctrl+Shift+F), Unicode 11 grapheme support, and inline image protocol. All existing functionality preserved. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 22:10:15 +02:00
Augustin	de52f4ebd6	fix(shell): restore all missing imports, constants, and utility functions All checks were successful Beta Release / beta (push) Successful in 49s Details - Restore xterm imports (Terminal, FitAddon, WebLinksAddon) - Restore all lucide-react icons (Globe, X, Plus, ChevronDown, etc.) - Restore module-level constants (AI_TAB_ID, MAX_TABS, SHELL_MAX_TOKENS, TABS_STORAGE_KEY, TERMINAL_BUFFER_KEY) - Restore renderContent() and formatText() utility functions - Add @xterm/xterm CSS import - Remove duplicate constants from inside Shell component 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 22:02:36 +02:00
Augustin	98ff0dd578	fix(shell): add missing Monitor import from lucide-react All checks were successful Beta Release / beta (push) Successful in 47s Details 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:56:32 +02:00
Augustin	9a1ff6e8dc	fix(shell): restore missing MAX_TABS, TABS_STORAGE_KEY, TERMINAL_BUFFER_KEY constants All checks were successful Beta Release / beta (push) Successful in 48s Details 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:53:38 +02:00
Augustin	034b9ee0e4	fix(shell): add missing useI18n import All checks were successful Beta Release / beta (push) Successful in 45s Details 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:51:54 +02:00
Augustin	c1b1fc653f	fix(shell): remove stray 'impo' typo causing ReferenceError All checks were successful Beta Release / beta (push) Successful in 44s Details 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:50:12 +02:00
Augustin	50ca75180c	fix(terminal): improve dimensions handling and add system theme for xterm All checks were successful Beta Release / beta (push) Successful in 47s Details 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 21:43:10 +02:00
Augustin	b8aa935bec	fix(shell): resolve savedTabs undefined ReferenceError in activeTab init All checks were successful Beta Release / beta (push) Successful in 50s Details 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:36:25 +02:00
Augustin	5627ddd2ce	fix(terminal): improve dimension calculation and tab init reliability All checks were successful Beta Release / beta (push) Successful in 48s Details - Guarantee minimum 24x80 dimensions on WebSocket open - Force reflow before init attempts - Multiple fit attempts with increasing delays (0/50/100/200/400ms) - Validate saved tabs structure from localStorage - Resize active tab after closing another tab 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:30:07 +02:00
Augustin	d27872572a	fix(dashboard): show MiMo quota instead of ZAI on dashboard All checks were successful Beta Release / beta (push) Successful in 47s Details Replace Z.AI quota display with MiMo provider in the API Quota card. ZAI is now a hidden fallback and should not appear in the dashboard. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:28:22 +02:00
Augustin	7d0f807fb0	feat(ai): add Xiaomi MiMo provider, ZAI as last-resort fallback All checks were successful Beta Release / beta (push) Successful in 57s Details Add MiMo-V2.5-Pro from Xiaomi Token Plan as a new AI provider with base URL https://token-plan-ams.xiaomimimo.com/v1. The /model change command now switches between MiniMax and MiMo only. ZAI is always placed last in the fallback chain as the provider of ultimate resort. Config panel shows MiniMax and MiMo cards. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:22:34 +02:00
Augustin	cbf623b98b	fix(terminal): use absolute positioning for content panels All checks were successful Beta Release / beta (push) Successful in 50s Details height:100% on .content>div fails because .content uses flex:1 without explicit height. Switch to position:absolute;inset:0 which correctly fills the content area and gives xterm proper container dimensions for fitAddon. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:13:20 +02:00
Augustin	b85ebb8e54	feat(terminal): add Ctrl+Shift+C/V copy/paste shortcuts All checks were successful Beta Release / beta (push) Successful in 48s Details xterm captures all keyboard input which prevents standard clipboard operations. Add custom key handler to intercept Ctrl+Shift+C for copy (selection) and Ctrl+Shift+V for paste, without interfering with Ctrl+C (SIGINT) or browser devtools shortcut. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:10:24 +02:00
Augustin	7cc206dc20	fix(shell): prevent Enter in AI chat from leaking to terminal All checks were successful Beta Release / beta (push) Successful in 48s Details Stop propagation of Enter keydown in AI input and defer terminal focus to next event loop tick to prevent xterm from capturing the same key event. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 21:07:36 +02:00
Augustin	bf8c0fd380	fix(terminal): improve terminal dimensions and fit timing All checks were successful Beta Release / beta (push) Successful in 47s Details Use min-height:0 on xterm-wrapper (flex child) instead of height:100% to properly fill available space in flex layout. Add delayed fit() calls after initialization to let the layout stabilize before calculating terminal cell dimensions. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 20:35:49 +02:00
Augustin	08dc1fd53b	fix(terminal): detect shell tab visibility via MutationObserver All checks were successful Beta Release / beta (push) Successful in 49s Details Shell is always mounted inside a display:none parent when the app loads on a different tab. Added MutationObserver on the wrapper to detect when the shell tab becomes visible and initialize/fit all pending terminals at that moment. Removed attempt limit so retries continue until the tab is actually shown. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 20:28:02 +02:00
Augustin	13e937a11b	fix(terminal): init all tabs on load, fix excessive zoom All checks were successful Beta Release / beta (push) Successful in 46s Details Use visibility:hidden instead of display:none for inactive terminal tabs so xterm containers retain their dimensions. This allows all terminals to initialize independently and prevents fitAddon from miscalculating cell sizes on zero-height containers. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-24 20:13:21 +02:00
Augustin	3cf701b002	fix(terminal): improve tab visibility checks and positioning All checks were successful Beta Release / beta (push) Successful in 48s Details - Add null check for container before accessing offsetHeight - Validate activeTabRef during initialization and fit operations - Check for display:none as visibility indicator - Simplify useEffect dependency array - Use absolute positioning for terminal wrapper/instance 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 17:59:48 +02:00
Augustin	3a09e0e0c2	fix(ui): adjust global CSS styles All checks were successful Beta Release / beta (push) Successful in 45s Details 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 17:38:21 +02:00
Augustin	47fa2e01bb	fix(terminal): use display:none instead of visibility for tab hiding All checks were successful Beta Release / beta (push) Successful in 49s Details Replace visibility-based hiding with display property for reliable tab detection. Use offsetParent and offsetHeight checks instead of style properties to properly detect hidden terminals. 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 17:23:54 +02:00
Augustin	401292ec5b	feat(ui): refactor copy state to Set and add helper functions All checks were successful Beta Release / beta (push) Successful in 46s Details - Change copiedIdx (number) to copiedSet (Set) for tracking multiple copied items - Add copyCmd function to handle clipboard and timeout cleanup - Add relativeTime function for displaying relative timestamps 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 17:04:38 +02:00
Augustin	199a7e409a	feat(ui): add recentUnique to deduplicate recent commands in Dashboard All checks were successful Beta Release / beta (push) Successful in 47s Details 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 17:01:08 +02:00
Augustin	c91931f42f	feat(ui): redesign recent commands display and fix terminal visibility All checks were successful Beta Release / beta (push) Successful in 44s Details - Dashboard: add frequency bars for top commands, click-to-copy, time display - Shell: switch from display:none to visibility:hidden for terminal containers - CSS: restyle command list with improved hover states and copy indicators 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 16:53:59 +02:00
Augustin	cbbb224725	fix(shell): initialize activeTabRef with activeTab and move useEffect All checks were successful Beta Release / beta (push) Successful in 45s Details Reorder code to follow React hooks rules - initialize ref with value instead of null, then update via useEffect. 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 16:44:02 +02:00
Augustin	8d10d2182e	fix(config): remove unused import, reorder hooks, and improve variable naming All checks were successful Beta Release / beta (push) Successful in 42s Details Reorder validateKey function and useEffect to avoid referencing before definition. Rename loop variable from 't' to 'tool' for clarity. 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 16:33:09 +02:00
Augustin	e9696ef82b	fix(studio): add tool results serialization and improve message handling All checks were successful Beta Release / beta (push) Successful in 43s Details - Add tool_results array to AI message content with tool_call_id, result, and is_error - Convert cleanContent to let for potential reuse - Reset accumulated and streaming state on tool_call events 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 16:22:54 +02:00