fix(config): remove unused import, reorder hooks, and improve variable naming

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>
fix(studio): add tool results serialization and improve message handling
2026-04-24 16:33:09 +02:00 · 2026-04-24 16:22:54 +02:00 · 2026-04-24 16:10:54 +02:00 · 2026-04-24 15:53:13 +02:00 · 2026-04-24 15:41:01 +02:00 · 2026-04-24 15:20:48 +02:00
16 changed files with 1462 additions and 529 deletions
--- a/.gitea/workflows/ci-main.yml
+++ b/.gitea/workflows/ci-main.yml
@@ -170,7 +170,7 @@ jobs:

      - name: Commit changelog
        env:
-          GITEA_TOKEN: ${{ secrets.GITEATOKEN }}
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
        run: |
          git config user.name "CI Bot"
          git config user.email "ci@legion-muyue.fr"
@@ -181,30 +181,45 @@ jobs:

      - name: Create release
        env:
-          GITEA_TOKEN: ${{ secrets.GITEATOKEN }}
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
        run: |
+          set -ex
          if [ -z "$GITEA_TOKEN" ]; then
-            echo "Warning: GITEATOKEN not set, skipping release"
-            exit 0
+            echo "Error: GITEA_TOKEN secret is not set"
+            exit 1
          fi
          VERSION=${{ steps.version.outputs.version }}
          API="${{ github.server_url }}/api/v1/repos/${{ github.repository }}/releases"
-          BODY=$(cat /tmp/stable_changelog.md)
-          RESPONSE=$(curl -s -X POST "${API}" \
+          echo "Creating release ${VERSION} at ${API}"
+
+          EXISTING=$(curl -sf -H "Authorization: token ${GITEA_TOKEN}" "${API}/tags/${VERSION}" || echo "")
+          if [ -n "$EXISTING" ]; then
+            EXISTING_ID=$(echo "$EXISTING" | python3 -c "import sys,json; print(json.load(sys.stdin).get('id',''))" 2>/dev/null || echo "")
+            if [ -n "$EXISTING_ID" ]; then
+              echo "Release ${VERSION} already exists (ID: ${EXISTING_ID}), deleting..."
+              curl -sf -X DELETE -H "Authorization: token ${GITEA_TOKEN}" "${API}/${EXISTING_ID}" || true
+            fi
+          fi
+
+          BODY=$(python3 -c "import json,sys; print(json.dumps(sys.stdin.read()))" < /tmp/stable_changelog.md)
+          RESPONSE=$(curl -s -w "\n%{http_code}" -X POST "${API}" \
            -H "Authorization: token ${GITEA_TOKEN}" \
            -H "Content-Type: application/json" \
            -d "{
              \"tag_name\":\"${VERSION}\",
              \"target_commitish\":\"main\",
              \"name\":\"muyue ${VERSION}\",
-              \"body\":$(echo "$BODY" | jq -Rs .),
+              \"body\":${BODY},
              \"draft\":false,
              \"prerelease\":false
            }")
-          RELEASE_ID=$(echo "$RESPONSE" | grep -o '"id":[0-9]*' | head -1 | grep -o '[0-9]*')
+          HTTP_CODE=$(echo "$RESPONSE" | tail -1)
+          RESPONSE_BODY=$(echo "$RESPONSE" | sed '$d')
+          echo "HTTP Status: ${HTTP_CODE}"
+          echo "Response: ${RESPONSE_BODY}"
+          RELEASE_ID=$(echo "$RESPONSE_BODY" | python3 -c "import sys,json; print(json.load(sys.stdin).get('id',''))" 2>/dev/null || echo "")
          if [ -z "$RELEASE_ID" ]; then
-            echo "Failed to create release:"
-            echo "$RESPONSE"
+            echo "Failed to create release"
            exit 1
          fi
          echo "Release ID: ${RELEASE_ID}"
@@ -212,8 +227,12 @@ jobs:
          for file in dist/*.tar.gz dist/*.zip dist/checksums.txt; do
            filename=$(basename "$file")
            echo "Uploading ${filename}..."
-            curl -s -X POST "${UPLOAD_URL}" \
+            UPLOAD_RESP=$(curl -s -w "\n%{http_code}" -X POST "${UPLOAD_URL}" \
              -H "Authorization: token ${GITEA_TOKEN}" \
-              -F "attachment=@${file};filename=${filename}" > /dev/null
+              -F "attachment=@${file};filename=${filename}")
+            UPLOAD_CODE=$(echo "$UPLOAD_RESP" | tail -1)
+            if [ "$UPLOAD_CODE" != "201" ]; then
+              echo "Upload failed with status ${UPLOAD_CODE}"
+            fi
          done
          echo "Stable release ${VERSION} published!"
--- a/internal/api/chat_engine.go
+++ b/internal/api/chat_engine.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
-	"strings"

 	"github.com/muyue/muyue/internal/agent"
 	"github.com/muyue/muyue/internal/orchestrator"
@@ -76,12 +75,8 @@ func (ce *ChatEngine) RunWithTools(ctx context.Context, messages []orchestrator.
 		content := cleanThinkingTags(choice.Message.Content)

 		if content != "" {
-			words := strings.Fields(content)
-			for _, w := range words {
-				chunk := w
-				if ce.onChunk != nil {
-					ce.onChunk(map[string]interface{}{"content": chunk})
-				}
+			if ce.onChunk != nil {
+				ce.onChunk(map[string]interface{}{"content": content})
 			}
 			finalContent = content
 		}
--- a/internal/api/handlers_info.go
+++ b/internal/api/handlers_info.go
@@ -8,6 +8,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"time"

@@ -477,9 +478,58 @@ func (s *Server) handleProvidersQuota(w http.ResponseWriter, r *http.Request) {
 				}
 			}
 		case "zai":
-			// Z.AI (GLM) est utilisé uniquement via Crush, pas de quota check externe
-			q.Healthy = true
-			q.Data = map[string]interface{}{"note": "crush-only"}
+			if p.APIKey == "" {
+				q.Error = "no API key"
+				results = append(results, q)
+				continue
+			}
+			req, _ := http.NewRequest("GET", "https://api.z.ai/api/monitor/usage/quota/limit", nil)
+			req.Header.Set("Authorization", "Bearer "+p.APIKey)
+			req.Header.Set("Accept", "application/json")
+			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 d, ok := data["data"].(map[string]interface{}); ok {
+						if limits, ok := d["limits"].([]interface{}); ok {
+							models := make([]map[string]interface{}, 0)
+							for _, l := range limits {
+								if lm, ok := l.(map[string]interface{}); ok {
+									name := "Z.AI"
+									if model, ok := lm["model"].(string); ok && model != "" {
+										name = model
+									} else if t, ok := lm["type"].(string); ok && t != "TIME_LIMIT" {
+										name = t
+									}
+									usage, _ := lm["usage"].(float64)
+									remaining, _ := lm["remaining"].(float64)
+									limitVal, hasLimit := lm["limit"].(float64)
+									total := usage + remaining
+									if hasLimit && limitVal > 0 {
+										total = limitVal
+									}
+									if total > 0 {
+										models = append(models, map[string]interface{}{
+											"model":     name,
+											"used":      usage,
+											"total":     total,
+											"remaining": remaining,
+										})
+									}
+								}
+							}
+							if len(models) > 0 {
+								q.Data = map[string]interface{}{"models": models}
+								q.Healthy = true
+							}
+						}
+					}
+				}
+			}
 		case "claude", "anthropic":
 			// Claude Code n'a pas d'API externe, vérifier l'installation
 			claudePath := "/usr/bin/claude"
@@ -516,10 +566,11 @@ func (s *Server) handleRecentCommands(w http.ResponseWriter, r *http.Request) {
 			shell = "zsh"
 		}
 		lines := strings.Split(string(data), "\n")
-		start := len(lines) - 25
+		start := len(lines) - 50
 		if start < 0 {
 			start = 0
 		}
+
 		for i := len(lines) - 1; i >= start; i-- {
 			line := strings.TrimSpace(lines[i])
 			if line == "" || strings.HasPrefix(line, "#") {
@@ -536,6 +587,15 @@ func (s *Server) handleRecentCommands(w http.ResponseWriter, r *http.Request) {
 			if line == "" {
 				continue
 			}
+
+			base := strings.Fields(line)[0]
+			if len(base) < 2 {
+				continue
+			}
+			if !regexp.MustCompile(`^[a-zA-Z@./]`).MatchString(base) {
+				continue
+			}
+
 			entries = append(entries, cmdEntry{Cmd: line, Shell: shell})
 		}
 	}
--- a/internal/api/handlers_shell_chat.go
+++ b/internal/api/handlers_shell_chat.go
@@ -1,53 +1,24 @@
 package api

 import (
-	"context"
 	"encoding/json"
+	"fmt"
 	"net/http"
+	"os"
+	"os/exec"
+	"runtime"
 	"strings"

+	"github.com/muyue/muyue/internal/agent"
 	"github.com/muyue/muyue/internal/orchestrator"
 )

-const maxShellToolIterations = 10
-
 type ShellChatRequest struct {
-	Message   string   `json:"message"`
-	Context   string   `json:"context,omitempty"`
-	History   []string `json:"history,omitempty"`
-	Cwd       string   `json:"cwd,omitempty"`
-	Platform  string   `json:"platform,omitempty"`
-	Stream    bool     `json:"stream"`
-}
-
-type ShellChatResponse struct {
-	Content   string        `json:"content,omitempty"`
-	ToolCalls []ToolCallInfo `json:"tool_calls,omitempty"`
-	Error     string        `json:"error,omitempty"`
-}
-
-type ToolCallInfo struct {
-	ID     string                 `json:"id"`
-	Name   string                 `json:"name"`
-	Args   map[string]interface{} `json:"args"`
-	Result *toolResponseData      `json:"result,omitempty"`
-	Error  string                 `json:"error,omitempty"`
-}
-
-func toString(v interface{}) string {
-	if v == nil {
-		return ""
-	}
-	s, _ := v.(string)
-	return s
-}
-
-func toBool(v interface{}) bool {
-	if v == nil {
-		return false
-	}
-	b, _ := v.(bool)
-	return b
+	Message  string `json:"message"`
+	Context  string `json:"context,omitempty"`
+	Cwd      string `json:"cwd,omitempty"`
+	Platform string `json:"platform,omitempty"`
+	Stream   bool   `json:"stream"`
 }

 func (s *Server) handleShellChat(w http.ResponseWriter, r *http.Request) {
@@ -56,6 +27,11 @@ func (s *Server) handleShellChat(w http.ResponseWriter, r *http.Request) {
 		return
 	}

+	if s.shellConvStore.AtLimit() {
+		writeError(w, "context limit reached, use /clear", http.StatusBadRequest)
+		return
+	}
+
 	var req ShellChatRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		writeError(w, err.Error(), http.StatusBadRequest)
@@ -67,142 +43,250 @@ func (s *Server) handleShellChat(w http.ResponseWriter, r *http.Request) {
 		return
 	}

+	s.shellConvStore.Add("user", req.Message)
+
 	orb, err := orchestrator.New(s.config)
 	if err != nil {
 		writeError(w, err.Error(), http.StatusServiceUnavailable)
 		return
 	}

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

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

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

-	sb.WriteString(`Tu es l'assistant Shell de Muyue. Tu as accès à un terminal et peux aider l'utilisateur avec:
- Exécuter des commandes shell
- Expliquer des erreurs de commandes
- Suggérer des commandes appropriées pour la tâche demandée
- Lire et explorer des fichiers
- Configurer l'environnement de développement
+	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.

-Tu peux appeler des outils pour exécuter des commandes, lire des fichiers, etc. Sois précis et concis dans tes réponses.
+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

 `)

-	if req.Cwd != "" {
-		sb.WriteString("Répertoire courant: " + req.Cwd + "\n")
+	analysis := LoadSystemAnalysis()
+	if analysis != "" {
+		sb.WriteString("=== ANALYSE SYSTÈME ACTUELLE ===\n")
+		sb.WriteString(analysis)
+		sb.WriteString("\n=== FIN DE L'ANALYSE ===\n\n")
 	}
-	if req.Platform != "" {
-		sb.WriteString("Plateforme: " + req.Platform + "\n")
-	}
-	if req.Context != "" {
-		sb.WriteString("\nContexte du terminal:\n" + req.Context + "\n")
-	}
-	if len(req.History) > 0 {
-		sb.WriteString("\nDernières commandes exécutées:\n")
-		for _, h := range req.History {
-			sb.WriteString("  " + h + "\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")
 	}

 	return sb.String()
 }

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

-	ctx := context.Background()
-	messages := []orchestrator.Message{
-		{Role: "user", Content: req.Message},
+	// 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
+		}
+		// Pre-load orchestrator history
+		orb.AppendHistory(orchestrator.Message{Role: m.Role, Content: m.Content})
 	}

-	engine := NewChatEngine(orb, s.agentRegistry, s.agentToolsJSON)
+	lastUserMsg := history[len(history)-1].Content

-	var toolCalls []ToolCallInfo
-	engine.OnChunk(func(data map[string]interface{}) {
-		if data == nil {
-			return
-		}
-		sseWriter.Write(data)
+	var finalContent string
+	result, err := orb.SendStream(lastUserMsg, func(chunk string) {
+		finalContent = chunk
+		sseWriter.Write(map[string]interface{}{"content": chunk})
 		if canFlush {
 			flusher.Flush()
 		}
-		if tc, ok := data["tool_call"].(map[string]interface{}); ok {
-			argsMap := make(map[string]interface{})
-			if args, ok := tc["args"].(string); ok {
-				json.Unmarshal([]byte(args), &argsMap)
-			}
-			toolCalls = append(toolCalls, ToolCallInfo{
-				ID:   toString(tc["tool_call_id"]),
-				Name: toString(tc["name"]),
-				Args: argsMap,
-			})
-		}
-		if tr, ok := data["tool_result"].(map[string]interface{}); ok {
-			tcID := toString(tr["tool_call_id"])
-			for i := range toolCalls {
-				if toolCalls[i].ID == tcID {
-					if err, ok := tr["is_error"].(bool); ok && err {
-						toolCalls[i].Error = toString(tr["content"])
-					} else {
-						toolCalls[i].Result = &toolResponseData{
-							Content: toString(tr["content"]),
-							IsError: toBool(tr["is_error"]),
-						}
-					}
-					break
-				}
-			}
-		}
 	})

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

-	if finalContent == "" && len(toolCalls) > 0 {
-		finalContent = "(opérations terminées)"
+	content := result
+	if content == "" {
+		content = finalContent
 	}

-	writeJSONResp, _ := json.Marshal(ShellChatResponse{
-		Content:   finalContent,
-		ToolCalls: toolCalls,
+	s.shellConvStore.Add("assistant", cleanThinkingTags(content))
+
+	sseWriter.Write(map[string]interface{}{
+		"done":   "true",
+		"tokens": s.shellConvStore.ApproxTokens(),
 	})
-	sseWriter.Write(map[string]interface{}{"done": true, "response": string(writeJSONResp)})
 }

-func (s *Server) handleShellChatNonStream(w http.ResponseWriter, orb *orchestrator.Orchestrator, req ShellChatRequest) {
-	ctx := context.Background()
-	messages := []orchestrator.Message{
-		{Role: "user", Content: req.Message},
+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})
 	}

-	engine := NewChatEngine(orb, s.agentRegistry, s.agentToolsJSON)
+	lastUserMsg := history[len(history)-1].Content

-	finalContent, err := engine.RunNonStream(ctx, messages)
+	result, err := orb.Send(lastUserMsg)
 	if err != nil {
 		writeError(w, err.Error(), http.StatusInternalServerError)
 		return
 	}

-	if finalContent == "" {
-		finalContent = "(tool calls completed, no text response)"
+	s.shellConvStore.Add("assistant", cleanThinkingTags(result))
+	writeJSON(w, map[string]interface{}{
+		"content": result,
+		"tokens":  s.shellConvStore.ApproxTokens(),
+	})
+}
+
+func (s *Server) handleShellChatHistory(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		writeError(w, "GET only", http.StatusMethodNotAllowed)
+		return
+	}
+	messages := s.shellConvStore.Get()
+	writeJSON(w, map[string]interface{}{
+		"messages":   messages,
+		"tokens":     s.shellConvStore.ApproxTokens(),
+		"max_tokens": shellMaxTokens,
+		"at_limit":   s.shellConvStore.AtLimit(),
+	})
+}
+
+func (s *Server) handleShellChatClear(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	s.shellConvStore.Clear()
+	writeJSON(w, map[string]interface{}{
+		"status": "ok",
+		"tokens": 0,
+	})
+}
+
+func (s *Server) handleShellAnalyze(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
 	}

-	writeJSON(w, ShellChatResponse{
-		Content:   finalContent,
-		ToolCalls: nil,
+	var sysInfo strings.Builder
+	sysInfo.WriteString("=== INFORMATIONS SYSTÈME ===\n")
+	sysInfo.WriteString(fmt.Sprintf("OS: %s/%s\n", runtime.GOOS, runtime.GOARCH))
+	if hostname, err := os.Hostname(); err == nil {
+		sysInfo.WriteString("Hostname: " + hostname + "\n")
+	}
+	if user := os.Getenv("USER"); user != "" {
+		sysInfo.WriteString("User: " + user + "\n")
+	}
+
+	if data, err := os.ReadFile("/proc/cpuinfo"); err == nil {
+		for _, line := range strings.Split(string(data), "\n") {
+			if strings.HasPrefix(line, "model name") {
+				sysInfo.WriteString("CPU: " + strings.SplitN(line, ":", 2)[1] + "\n")
+				break
+			}
+		}
+	}
+
+	if data, err := os.ReadFile("/proc/meminfo"); err == nil {
+		for _, line := range strings.Split(string(data), "\n") {
+			if strings.HasPrefix(line, "MemTotal:") || strings.HasPrefix(line, "MemAvailable:") {
+				sysInfo.WriteString(strings.TrimSpace(line) + "\n")
+			}
+		}
+	}
+
+	if out, err := exec.Command("df", "-h", "/").Output(); err == nil {
+		lines := strings.Split(string(out), "\n")
+		if len(lines) >= 2 {
+			sysInfo.WriteString("Disk: " + strings.TrimSpace(lines[1]) + "\n")
+		}
+	}
+
+	if out, err := exec.Command("ps", "aux", "--sort=-pcpu").Output(); err == nil {
+		lines := strings.Split(string(out), "\n")
+		sysInfo.WriteString(fmt.Sprintf("\nProcessus actifs (%d total):\n", len(lines)-1))
+		for i := 1; i < len(lines) && i <= 10; i++ {
+			fields := strings.Fields(lines[i])
+			if len(fields) >= 11 {
+				sysInfo.WriteString(fmt.Sprintf("  %-20s CPU:%-6s MEM:%-6s %s\n", fields[10], fields[2]+"%", fields[3]+"%", fields[0]))
+			}
+		}
+	}
+
+	if s.scanResult != nil {
+		sysInfo.WriteString("\nOutils installés:\n")
+		for _, t := range s.scanResult.Tools {
+			status := "✗"
+			if t.Installed {
+				status = "✓"
+			}
+			sysInfo.WriteString(fmt.Sprintf("  %s %s %s\n", status, t.Name, t.Version))
+		}
+	}
+
+	orb, err := orchestrator.New(s.config)
+	if err != nil {
+		writeError(w, err.Error(), http.StatusServiceUnavailable)
+		return
+	}
+	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
+
+Sois concret et technique. Le rapport sera utilisé comme contexte pour un assistant terminal.
+
+` + sysInfo.String()
+
+	result, err := orb.Send(analysisPrompt)
+	if err != nil {
+		writeError(w, "analysis failed: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	SaveSystemAnalysis(result)
+
+	writeJSON(w, map[string]interface{}{
+		"status":   "ok",
+		"analysis": result,
 	})
-}
+}
+
+func (s *Server) handleShellAnalysisGet(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		writeError(w, "GET only", http.StatusMethodNotAllowed)
+		return
+	}
+	analysis := LoadSystemAnalysis()
+	if analysis == "" {
+		writeJSON(w, map[string]interface{}{"analysis": nil})
+		return
+	}
+	writeJSON(w, map[string]interface{}{"analysis": analysis})
+}
--- a/internal/api/server.go
+++ b/internal/api/server.go
@@ -17,6 +17,7 @@ type Server struct {
 	scanResult     *scanner.ScanResult
 	mux            *http.ServeMux
 	convStore      *ConversationStore
+	shellConvStore *ShellConvStore
 	agentRegistry  *agent.Registry
 	agentToolsJSON json.RawMessage
 	workflowEngine *workflow.Engine
@@ -46,6 +47,7 @@ func NewServer(cfg *config.MuyueConfig) *Server {
 	s.config = cfg
 	s.scanResult = scanner.ScanSystem()
 	s.convStore = NewConversationStore()
+	s.shellConvStore = NewShellConvStore()
 	s.agentRegistry = agent.DefaultRegistry()
 	tools := s.agentRegistry.OpenAITools()
 	toolsJSON, _ := json.Marshal(tools)
@@ -89,6 +91,10 @@ func (s *Server) routes() {
 	s.mux.HandleFunc("/api/tool/call", s.handleToolCall)
 	s.mux.HandleFunc("/api/tools/list", s.handleToolList)
 	s.mux.HandleFunc("/api/shell/chat", s.handleShellChat)
+	s.mux.HandleFunc("/api/shell/chat/history", s.handleShellChatHistory)
+	s.mux.HandleFunc("/api/shell/chat/clear", s.handleShellChatClear)
+	s.mux.HandleFunc("/api/shell/analyze", s.handleShellAnalyze)
+	s.mux.HandleFunc("/api/shell/analysis", s.handleShellAnalysisGet)
 	s.mux.HandleFunc("/api/workflow", s.handleWorkflowCreate)
 	s.mux.HandleFunc("/api/workflow/list", s.handleWorkflowList)
 	s.mux.HandleFunc("/api/workflow/", s.handleWorkflowGet)
--- a/internal/api/shell_conversation.go
+++ b/internal/api/shell_conversation.go
@@ -0,0 +1,121 @@
+package api
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+	"unicode/utf8"
+
+	"github.com/muyue/muyue/internal/config"
+)
+
+const shellMaxTokens = 100000
+const shellCharsPerToken = 4
+
+type ShellMessage struct {
+	ID      string `json:"id"`
+	Role    string `json:"role"`
+	Content string `json:"content"`
+	Time    string `json:"time"`
+}
+
+type ShellConvStore struct {
+	mu   sync.RWMutex
+	path string
+	msgs []ShellMessage
+}
+
+func NewShellConvStore() *ShellConvStore {
+	dir, err := config.ConfigDir()
+	if err != nil {
+		dir = "/tmp/muyue"
+	}
+	path := filepath.Join(dir, "shell_conversation.json")
+	s := &ShellConvStore{path: path}
+	s.load()
+	return s
+}
+
+func (s *ShellConvStore) load() {
+	data, err := os.ReadFile(s.path)
+	if err != nil {
+		s.msgs = []ShellMessage{}
+		return
+	}
+	json.Unmarshal(data, &s.msgs)
+	if s.msgs == nil {
+		s.msgs = []ShellMessage{}
+	}
+}
+
+func (s *ShellConvStore) save() {
+	data, _ := json.MarshalIndent(s.msgs, "", "  ")
+	os.MkdirAll(filepath.Dir(s.path), 0755)
+	os.WriteFile(s.path, data, 0600)
+}
+
+func (s *ShellConvStore) Get() []ShellMessage {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	out := make([]ShellMessage, len(s.msgs))
+	copy(out, s.msgs)
+	return out
+}
+
+func (s *ShellConvStore) Add(role, content string) ShellMessage {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	msg := ShellMessage{
+		ID:      time.Now().Format("20060102150405.000"),
+		Role:    role,
+		Content: content,
+		Time:    time.Now().Format(time.RFC3339),
+	}
+	s.msgs = append(s.msgs, msg)
+	s.save()
+	return msg
+}
+
+func (s *ShellConvStore) Clear() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.msgs = []ShellMessage{}
+	s.save()
+}
+
+func (s *ShellConvStore) ApproxTokens() int {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	total := 0
+	for _, m := range s.msgs {
+		total += utf8.RuneCountInString(m.Content) / shellCharsPerToken
+	}
+	return total
+}
+
+func (s *ShellConvStore) AtLimit() bool {
+	return s.ApproxTokens() >= shellMaxTokens
+}
+
+func LoadSystemAnalysis() string {
+	dir, err := config.ConfigDir()
+	if err != nil {
+		return ""
+	}
+	data, err := os.ReadFile(filepath.Join(dir, "system_analysis.md"))
+	if err != nil {
+		return ""
+	}
+	return string(data)
+}
+
+func SaveSystemAnalysis(content string) error {
+	dir, err := config.ConfigDir()
+	if err != nil {
+		return err
+	}
+	os.MkdirAll(dir, 0755)
+	return os.WriteFile(filepath.Join(dir, "system_analysis.md"), []byte(content), 0644)
+}
--- a/internal/api/terminal.go
+++ b/internal/api/terminal.go
@@ -146,13 +146,6 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	log.Printf("terminal: pty started successfully")
-	defer func() {
-		ptmx.Close()
-		if cmd.Process != nil {
-			cmd.Process.Kill()
-			cmd.Wait()
-		}
-	}()

 	var once sync.Once
 	cleanup := func() {
@@ -164,6 +157,7 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 			}
 		})
 	}
+	defer cleanup()

 	go func() {
 		buf := make([]byte, 4096)
@@ -171,8 +165,6 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 			n, err := ptmx.Read(buf)
 			if err != nil {
 				cleanup()
-				conn.WriteMessage(websocket.CloseMessage,
-					websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
 				return
 			}
 			if err := conn.WriteJSON(wsMessage{
@@ -230,12 +222,11 @@ func (s *Server) handleTerminalSessions(w http.ResponseWriter, r *http.Request)
 		return
 	}
 	var body struct {
-		Name     string `json:"name"`
-		Host     string `json:"host"`
-		Port     int    `json:"port"`
-		User     string `json:"user"`
-		Password string `json:"password"`
-		KeyPath  string `json:"key_path"`
+		Name    string `json:"name"`
+		Host    string `json:"host"`
+		Port    int    `json:"port"`
+		User    string `json:"user"`
+		KeyPath string `json:"key_path"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 		writeError(w, err.Error(), http.StatusBadRequest)
--- a/internal/version/version.go
+++ b/internal/version/version.go
@@ -7,7 +7,7 @@ import (

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

--- a/web/src/api/client.js
+++ b/web/src/api/client.js
@@ -57,6 +57,10 @@ const api = {
  getChatHistory: () => request('/chat/history'),
  clearChat: () => request('/chat/clear', { method: 'POST' }),
  summarizeChat: () => request('/chat/summarize', { method: 'POST' }),
+  getShellChatHistory: () => request('/shell/chat/history'),
+  clearShellChat: () => request('/shell/chat/clear', { method: 'POST' }),
+  analyzeSystem: () => request('/shell/analyze', { method: 'POST' }),
+  getShellAnalysis: () => request('/shell/analysis'),
  sendChat: (message, stream = true, onChunk, signal) => {
    if (!stream) {
      return request('/chat', { method: 'POST', body: JSON.stringify({ message, stream: false }) })
@@ -101,11 +105,9 @@ const api = {
      }).catch(reject)
    })
  },
-  sendShellChat: (message, context = {}, stream = true, onChunk) => {
+  sendShellChat: (message, context = {}, stream = true, onChunk, signal) => {
    const payload = {
      message,
-      context: context.context || '',
-      history: context.history || [],
      cwd: context.cwd || '',
      platform: context.platform || '',
      stream,
@@ -118,6 +120,7 @@ const api = {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(payload),
+        signal,
      }).then(async (res) => {
        if (!res.ok) {
          const err = await res.json().catch(() => ({ error: res.statusText }))
@@ -127,7 +130,6 @@ const api = {
        const reader = res.body.getReader()
        const decoder = new TextDecoder()
        let full = ''
-        let toolCalls = []
        while (true) {
          const { done, value } = await reader.read()
          if (done) break
@@ -137,27 +139,15 @@ const api = {
            try {
              const data = JSON.parse(line.slice(6))
              if (data.error) { reject(new Error(data.error)); return }
-              if (data.done) {
-                resolve({ content: full, tool_calls: toolCalls })
-                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) {
-                toolCalls.push(data.tool_call)
-                if (onChunk) onChunk(full, data, toolCalls)
-              } else if (data.tool_result) {
-                const idx = toolCalls.findIndex(tc => tc.tool_call_id === data.tool_result.id)
-                if (idx >= 0) {
-                  toolCalls[idx].result = data.tool_result
-                }
-                if (onChunk) onChunk(full, data, toolCalls)
              }
            } catch {}
          }
        }
-        resolve({ content: full, tool_calls: toolCalls })
+        resolve({ content: full })
      }).catch(reject)
    })
  },
--- a/web/src/components/App.jsx
+++ b/web/src/components/App.jsx
@@ -76,6 +76,12 @@ export default function App() {

  const switchTab = useCallback((tabId) => setActiveTab(tabId), [])

+  useEffect(() => {
+    const handler = () => setActiveTab('shell')
+    window.addEventListener('navigate-to-shell', handler)
+    return () => window.removeEventListener('navigate-to-shell', handler)
+  }, [])
+
  const hasUpdates = updates.some(u => u.needsUpdate)
  const installed = tools.filter(tool => tool.installed).length

@@ -92,16 +98,6 @@ export default function App() {
    config: [],
  }), [layout, t])

-  const renderContent = () => {
-    switch (activeTab) {
-      case 'dash': return <Dashboard api={api} refreshRef={dashRefreshRef} />
-      case 'studio': return <Studio api={api} />
-      case 'shell': return <Shell api={api} />
-      case 'config': return <Config api={api} />
-      default: return null
-    }
-  }
-
  return (
    <div className="app-layout">
      <header className="header">
@@ -143,8 +139,11 @@ export default function App() {
        </span>
      </header>

-      <main className="content fade-in" key={`${activeTab}-${TABS.length}`}>
-        {renderContent()}
+      <main className="content">
+        <div className={activeTab === 'dash' ? '' : 'tab-hidden'}><Dashboard api={api} refreshRef={dashRefreshRef} /></div>
+        <div className={activeTab === 'studio' ? '' : 'tab-hidden'}><Studio api={api} /></div>
+        <div className={activeTab === 'shell' ? '' : 'tab-hidden'}><Shell api={api} /></div>
+        <div className={activeTab === 'config' ? '' : 'tab-hidden'}><Config api={api} /></div>
      </main>

      <footer className="statusbar">
--- a/web/src/components/Config.jsx
+++ b/web/src/components/Config.jsx
@@ -1,13 +1,11 @@
 import { useState, useEffect, useCallback } from 'react'
-import { User, Brain, RefreshCw, Globe, Wrench, Monitor } from 'lucide-react'
-import { useI18n, LANGUAGES } from '../i18n'
-import { getLayoutList } from '../i18n/keyboards'
+import { User, Brain, RefreshCw, Wrench, Monitor, AlertTriangle } from 'lucide-react'
+import { useI18n } from '../i18n'

 const PANELS = [
  { id: 'profile', icon: User },
  { id: 'providers', icon: Brain },
  { id: 'updates', icon: RefreshCw },
-  { id: 'locale', icon: Globe },
  { id: 'skills', icon: Wrench },
  { id: 'system', icon: Monitor },
 ]
@@ -29,8 +27,6 @@ export default function Config({ api }) {
  const [toast, setToast] = useState(null)


-  const layouts = getLayoutList()
-
  const loadData = useCallback(() => {
    api.getConfig().then(d => {
      setConfig(d)
@@ -65,28 +61,15 @@ export default function Config({ api }) {
    setChecking(false)
  }

-  const handleUpdateTool = async (tool) => {
-    setUpdating(tool)
-    try {
-      await api.runUpdate(tool)
-      await handleCheckUpdates()
-      showToast(`${tool} ✓`)
-    } catch (err) {
-      showToast(`${t('config.error')}: ${err.message}`)
-    }
-    setUpdating(null)
+  const handleUpdateTool = (tool) => {
+    window.dispatchEvent(new CustomEvent('navigate-to-shell', {}))
+    window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: `Met à jour l'outil ${tool} sur mon système. Exécute les commandes nécessaires.` } }))
  }

-  const handleUpdateAll = async () => {
-    setUpdating('__all__')
-    try {
-      await api.runUpdate('')
-      await handleCheckUpdates()
-      showToast(t('config.saved'))
-    } catch (err) {
-      showToast(`${t('config.error')}: ${err.message}`)
-    }
-    setUpdating(null)
+  const handleUpdateAll = () => {
+    const toUpdate = updates.filter(u => u.needsUpdate).map(u => u.tool)
+    window.dispatchEvent(new CustomEvent('navigate-to-shell', {}))
+    window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: `Met à jour tous les outils suivants sur mon système : ${toUpdate.join(', ')}. Exécute les commandes nécessaires une par une.` } }))
  }

  const handleSaveProfile = async () => {
@@ -181,13 +164,6 @@ export default function Config({ api }) {
              t={t}
            />
          )}
-          {activePanel === 'locale' && (
-            <PanelLocale
-              language={language} keyboard={keyboard} layouts={layouts}
-              api={api}
-              t={t}
-            />
-          )}
          {activePanel === 'skills' && (
            <PanelSkills skillList={skillList} t={t} />
          )}
@@ -333,39 +309,57 @@ function getFieldLabel(key, t) {

 function PanelProviders({ providers, editProvider, providerForm, setProviderForm, setEditProvider, openProviderEdit, handleSaveProvider, api, loadData, t }) {
  const [validating, setValidating] = useState(null)
-  const [validationStatus, setValidationStatus] = useState(null)
+  const [keyStatus, setKeyStatus] = useState({})

-  const handleValidate = async (name, apiKey, model, baseUrl) => {
-    setValidating(name)
-    setValidationStatus(null)
+  const validateKey = async (p) => {
+    setValidating(p.name)
    try {
-      await api.validateProvider({ name, api_key: apiKey, model, base_url: baseUrl })
-      setValidationStatus({ provider: name, valid: true })
+      await api.validateProvider({ name: p.name, api_key: p.apiKey, model: p.model, base_url: p.baseURL || '' })
+      setKeyStatus(prev => ({ ...prev, [p.name]: { valid: true, checked: true } }))
    } catch (err) {
-      const msg = err.message || ''
-      if (msg.includes('invalid_api_key')) {
-        setValidationStatus({ provider: name, valid: false, error: t('config.keyInvalid') })
-      } else {
-        setValidationStatus({ provider: name, valid: false, error: `${t('config.connectionFailed')}: ${msg}` })
-      }
+      setKeyStatus(prev => ({ ...prev, [p.name]: { valid: false, checked: true, error: err.message || 'Clé invalide' } }))
    }
    setValidating(null)
  }

+  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 handleValidate = async (name, apiKey, model, baseUrl) => {
+    setValidating(name)
+    try {
+      await api.validateProvider({ name, api_key: apiKey, model, base_url: baseUrl })
+      setKeyStatus(prev => ({ ...prev, [name]: { valid: true, checked: true } }))
+    } catch (err) {
+      setKeyStatus(prev => ({ ...prev, [name]: { valid: false, checked: true, error: err.message || 'Clé invalide' } }))
+    }
+    setValidating(null)
+  }
+
+  const displayed = providers.filter(p => p.name === 'minimax' || p.name === 'zai')
+
  return (
    <div className="config-providers-list">
-      <div className="provider-setup-hint">{t('config.setupDescription')}</div>
-      {providers.map((p, i) => {
+      {displayed.map((p, i) => {
        const isEditing = editProvider === p.name
-        const isValidationTarget = validationStatus?.provider === p.name
+        const currentModel = providerForm[p.name]?.model || p.model
+        const status = keyStatus[p.name]
+
        return (
          <div key={i} className="config-card provider-card-v2">
            <div className="provider-card-top">
              <div className="provider-card-identity">
-                <span className="provider-card-name">{p.name}</span>
+                <span className="provider-card-name">{p.name.toUpperCase()}</span>
                {p.active && <span className="badge ok" style={{ marginLeft: 6 }}>active</span>}
-                {isValidationTarget && validationStatus?.valid && <span className="badge ok">{t('config.keyValid')}</span>}
-                {isValidationTarget && !validationStatus?.valid && <span className="badge error">{validationStatus?.error}</span>}
+                {status?.checked && status?.valid && <span className="badge ok">✓ {t('config.keyValid')}</span>}
+                {status?.checked && !status?.valid && <span className="badge error">✗ {status.error || t('config.keyInvalid')}</span>}
              </div>
            </div>

@@ -376,7 +370,7 @@ function PanelProviders({ providers, editProvider, providerForm, setProviderForm
                  <input
                    className="config-form-input"
                    type="password"
-                    placeholder={t('config.tokenPlaceholder')}
+                    placeholder={p.apiKey ? '••••••••' : t('config.tokenPlaceholder')}
                    value={isEditing ? (providerForm[p.name]?.api_key || '') : ''}
                    onChange={e => {
                      if (!isEditing) openProviderEdit(p)
@@ -391,18 +385,18 @@ function PanelProviders({ providers, editProvider, providerForm, setProviderForm
                  <button
                    className="sm primary"
                    disabled={validating === p.name || !providerForm[p.name]?.api_key}
-                    onClick={() => handleValidate(p.name, providerForm[p.name]?.api_key, providerForm[p.name]?.model, providerForm[p.name]?.base_url)}
+                    onClick={() => handleValidate(p.name, providerForm[p.name]?.api_key, currentModel, providerForm[p.name]?.base_url)}
                  >
                    {validating === p.name ? t('config.validating') : t('config.validateKey')}
                  </button>
-                  {isValidationTarget && validationStatus?.valid && (
+                  {isEditing && (
                    <button className="sm" onClick={() => handleSaveProvider(p.name)}>{t('config.save')}</button>
                  )}
                </div>
              </div>
-              <div className="provider-card-meta" style={{ marginTop: 8 }}>
-                {p.active && <span className="badge ok" style={{ marginRight: 6 }}>active</span>}
-                {p.model && p.model !== p.name && <span className="mono">{p.model}</span>}
+              <div className="provider-card-model">
+                <span className="provider-card-model-label">{t('config.model')}</span>
+                <span className="provider-card-model-value">{p.model || '—'}</span>
              </div>
            </div>
          </div>
@@ -412,7 +406,14 @@ function PanelProviders({ providers, editProvider, providerForm, setProviderForm
  )
 }

-function PanelUpdates({ updates, checking, updating, needsUpdateCount, installedCount, missingCount, handleCheckUpdates, handleUpdateTool, handleUpdateAll, t }) {
+function PanelUpdates({ updates, tools, checking, updating, needsUpdateCount, installedCount, missingCount, handleCheckUpdates, handleUpdateTool, handleUpdateAll, t }) {
+  const handleInstallTool = (tool) => {
+    window.dispatchEvent(new CustomEvent('navigate-to-shell', {}))
+    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(tool => !tool.installed)
+
  return (
    <>
      <div className="config-card">
@@ -435,6 +436,30 @@ function PanelUpdates({ updates, checking, updating, needsUpdateCount, installed
        </div>
      </div>

+      {missingTools.length > 0 && (
+        <>
+          <div className="section-title" style={{ marginTop: 12, marginBottom: 4 }}>{t('config.missing') || 'Modules manquants'}</div>
+          <div className="config-update-list">
+            {missingTools.map((tool, i) => (
+              <div key={`miss-${i}`} className="config-update-row">
+                <div className="config-update-info">
+                  <span className="config-update-name">{tool.name}</span>
+                  <span className="config-update-versions">
+                    <span style={{ color: 'var(--danger)' }}>{t('config.notInstalled') || 'Non installé'}</span>
+                  </span>
+                </div>
+                <button
+                  className="sm primary"
+                  onClick={() => handleInstallTool(tool.name)}
+                >
+                  {t('config.install') || 'Installer'}
+                </button>
+              </div>
+            ))}
+          </div>
+        </>
+      )}
+
      {updates.length === 0 ? (
        <div className="config-card">
          <div className="empty-state">{t('config.noUpdates')}</div>
@@ -470,129 +495,90 @@ function PanelUpdates({ updates, checking, updating, needsUpdateCount, installed
  )
 }

-function PanelLocale({ language, keyboard, layouts, api, t }) {
-  const { setLanguage, setKeyboard } = useI18n()
-  const [editLocale, setEditLocale] = useState(false)
-  const [draftLang, setDraftLang] = useState(language)
-  const [draftKbd, setDraftKbd] = useState(keyboard)
-  const [saving, setSaving] = useState(false)
-  const [toast, setToast] = useState(null)

-  const showToast = (msg) => {
-    setToast(msg)
-    setTimeout(() => setToast(null), 2500)
-  }
-
-  const handleSave = async () => {
-    setSaving(true)
-    try {
-      await api.savePreferences({ language: draftLang, keyboard_layout: draftKbd })
-      setLanguage(draftLang)
-      setKeyboard(draftKbd)
-      setEditLocale(false)
-      showToast(t('config.saved'))
-    } catch (err) {
-      showToast(`${t('config.error')}: ${err.message}`)
-    }
-    setSaving(false)
-  }
-
-  const currentLang = LANGUAGES.find(l => l.id === language)
-  const currentKbd = layouts.find(l => l.id === keyboard)
-
-  return (
-    <div className="config-profile-center">
-      {toast && <div className="config-toast">{toast}</div>}
-      <div className="config-card">
-        <div className="config-card-row">
-          <span className="config-card-label">{t('config.language')}</span>
-          <span className="config-card-value">{currentLang?.name || language}</span>
-        </div>
-        <div className="config-card-row">
-          <span className="config-card-label">{t('config.keyboardLayout')}</span>
-          <span className="config-card-value">{currentKbd?.name || keyboard}</span>
-        </div>
-      </div>
-      {editLocale && (
-        <div className="config-card">
-          <div className="config-card-group">
-            <span className="config-card-group-label">{t('config.language')}</span>
-            <div className="chip-row">
-              {LANGUAGES.map(lang => (
-                <div
-                  key={lang.id}
-                  className={`chip ${draftLang === lang.id ? 'active' : ''}`}
-                  onClick={() => setDraftLang(lang.id)}
-                >
-                  {lang.name}
-                </div>
-              ))}
-            </div>
-          </div>
-          <div className="config-card-group">
-            <span className="config-card-group-label">{t('config.keyboardLayout')}</span>
-            <div className="chip-row">
-              {layouts.map(l => (
-                <div
-                  key={l.id}
-                  className={`chip ${draftKbd === l.id ? 'active' : ''}`}
-                  onClick={() => setDraftKbd(l.id)}
-                >
-                  {l.name}
-                </div>
-              ))}
-            </div>
-          </div>
-        </div>
-      )}
-      <div className="config-card">
-        <div className="config-card-actions" style={{ justifyContent: 'center' }}>
-          {editLocale ? (
-            <>
-              <button className="primary sm" onClick={handleSave} disabled={saving}>
-                {saving ? t('config.saving') : t('config.save')}
-              </button>
-              <button className="ghost sm" onClick={() => setEditLocale(false)}>{t('config.cancel')}</button>
-            </>
-          ) : (
-            <button className="primary sm" onClick={() => { setDraftLang(language); setDraftKbd(keyboard); setEditLocale(true) }}>{t('config.editProfile')}</button>
-          )}
-        </div>
-      </div>
-    </div>
-  )
-}

 function PanelSkills({ skillList, t }) {
+  const [selected, setSelected] = useState(null)
+
+  if (skillList.length === 0) {
+    return <div className="empty-state" style={{ color: 'var(--text-disabled)', padding: 40 }}>{t('config.noSkills')}</div>
+  }
+
  return (
-    <div className="config-card">
-      {skillList.length === 0 ? (
-        <div className="empty-state">
-          {t('config.noSkills')}
-          <span style={{ fontFamily: 'var(--font-mono)' }}>{t('config.runSkillsInit')}</span>
-        </div>
-      ) : (
-        skillList.map((s, i) => (
-          <div key={i} className="config-skill-row">
-            <span className="config-skill-name">{s.name}</span>
-            <span className="badge neutral">{s.target || 'both'}</span>
-            {s.version && <span className="badge" style={{ fontSize: 10 }}>{s.version}</span>}
-            {s.category && <span className="badge" style={{ fontSize: 10, opacity: 0.7 }}>{s.category}</span>}
-            <span className="config-skill-desc">{s.description}</span>
-            {s.dependencies && s.dependencies.length > 0 && (
-              <div style={{ marginTop: 4, fontSize: 10, color: 'var(--muted)' }}>
-                deps: {s.dependencies.map(d => d.name).join(', ')}
-              </div>
-            )}
+    <>
+      <div className="skill-tiles">
+        {skillList.map((s, i) => (
+          <div key={i} className="skill-tile" onClick={() => setSelected(s)}>
+            <div className="skill-tile-name">{s.name}</div>
+            <div className="skill-tile-desc">{s.description}</div>
+            <div className="skill-tile-tags">
+              {s.target && <span className="badge neutral">{s.target}</span>}
+              {s.version && <span className="badge">{s.version}</span>}
+              {s.category && <span className="badge" style={{ opacity: 0.7 }}>{s.category}</span>}
+            </div>
          </div>
-        ))
+        ))}
+      </div>
+      {selected && (
+        <div className="skill-detail-overlay" onClick={() => setSelected(null)}>
+          <div className="skill-detail-panel" onClick={e => e.stopPropagation()}>
+            <div className="skill-detail-header">
+              <span className="skill-detail-name">{selected.name}</span>
+              <button className="ghost sm" onClick={() => setSelected(null)}>✕</button>
+            </div>
+            <div className="skill-detail-body">
+              <div className="skill-detail-section">
+                <div className="skill-detail-label">Description</div>
+                <div style={{ fontSize: 13, color: 'var(--text-secondary)' }}>{selected.description}</div>
+              </div>
+              <div className="skill-detail-section">
+                <div className="skill-detail-label">Métadonnées</div>
+                <div className="skill-detail-meta">
+                  {selected.target && <span className="badge neutral">{selected.target}</span>}
+                  {selected.version && <span className="badge">{selected.version}</span>}
+                  {selected.category && <span className="badge">{selected.category}</span>}
+                  {selected.author && <span className="badge ghost">{selected.author}</span>}
+                  {selected.languages && selected.languages.map(l => <span key={l} className="badge ghost">{l}</span>)}
+                </div>
+              </div>
+              {selected.tags && selected.tags.length > 0 && (
+                <div className="skill-detail-section">
+                  <div className="skill-detail-label">Tags</div>
+                  <div className="chip-row">
+                    {selected.tags.map(tag => <span key={tag} className="badge">{tag}</span>)}
+                  </div>
+                </div>
+              )}
+              {selected.content && (
+                <div className="skill-detail-section">
+                  <div className="skill-detail-label">Contenu</div>
+                  <div className="skill-detail-content">{selected.content}</div>
+                </div>
+              )}
+              {selected.dependencies && selected.dependencies.length > 0 && (
+                <div className="skill-detail-section">
+                  <div className="skill-detail-label">Dépendances</div>
+                  <div className="skill-detail-deps">
+                    {selected.dependencies.map((d, i) => (
+                      <div key={i} className="skill-detail-dep">
+                        <span className="badge">{d.type}</span>
+                        <span>{d.name}</span>
+                        {d.required === false && <span style={{ fontSize: 11, color: 'var(--text-disabled)' }}>optionnel</span>}
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
      )}
-    </div>
+    </>
  )
 }

 function PanelSystem({ api, t }) {
-  const [resetConfirm, setResetConfirm] = useState(false)
+  const [showResetModal, setShowResetModal] = useState(false)
  const [toast, setToast] = useState(null)

  const showToast = (msg) => {
@@ -603,7 +589,7 @@ function PanelSystem({ api, t }) {
  const handleReset = async () => {
    try {
      await api.resetConfig()
-      setResetConfirm(false)
+      setShowResetModal(false)
      showToast(t('config.resetDone'))
      setTimeout(() => window.location.reload(), 1500)
    } catch (err) {
@@ -611,49 +597,66 @@ function PanelSystem({ api, t }) {
    }
  }

-  const handleApplyStarship = async () => {
-    try {
-      await api.applyStarshipTheme('charm')
-      showToast(t('config.starshipApplied'))
-    } catch (err) {
-      showToast(`${t('config.error')}: ${err.message}`)
-    }
+  const handleApplyStarship = () => {
+    window.dispatchEvent(new CustomEvent('navigate-to-shell', {}))
+    window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: `Vérifie si starship est installé sur le système. S'il ne l'est pas, installe-le (avec curl ou le gestionnaire de paquets). Ensuite, applique la configuration du thème "charm" pour starship. Assure-toi que starship est bien initialisé dans le shell de l'utilisateur.` } }))
  }

  return (
    <>
      {toast && <div className="config-toast">{toast}</div>}
+
+      <div className="section-title" style={{ marginBottom: 8 }}>Configuration Système</div>
      <div className="config-card">
        <div className="config-card-row" style={{ marginBottom: 16 }}>
          <span className="config-card-label" style={{ fontWeight: 600 }}>{t('config.applyStarship')}</span>
        </div>
-        <div style={{ fontSize: 12, color: 'var(--muted)', marginBottom: 12 }}>
-          {t('config.starshipApplied')}
+        <div style={{ fontSize: 12, color: 'var(--text-tertiary)', marginBottom: 12 }}>
+          Vérifie l'installation de starship et configure le thème charm via l'IA.
        </div>
        <button className="sm primary" onClick={handleApplyStarship}>
          {t('config.applyStarship')}
        </button>
      </div>
-      <div className="config-card" style={{ marginTop: 12 }}>
+
+      <div className="section-title" style={{ marginTop: 20, marginBottom: 8, color: 'var(--danger)' }}>
+        <AlertTriangle size={14} style={{ verticalAlign: 'middle', marginRight: 6 }} />
+        Zone Rouge
+      </div>
+      <div className="config-card" style={{ borderColor: 'var(--danger)', borderWidth: 1, borderStyle: 'solid' }}>
        <div className="config-card-row" style={{ marginBottom: 16 }}>
-          <span className="config-card-label" style={{ fontWeight: 600 }}>{t('config.resetConfig')}</span>
+          <span className="config-card-label" style={{ fontWeight: 600, color: 'var(--danger)' }}>{t('config.resetConfig')}</span>
        </div>
-        {resetConfirm ? (
-          <div>
-            <div style={{ fontSize: 12, color: 'var(--warning)', marginBottom: 12 }}>
-              {t('config.resetConfirm')}
+        <div style={{ fontSize: 12, color: 'var(--text-tertiary)', marginBottom: 12 }}>
+          Cette action supprimera toute votre configuration et relancera l'application.
+        </div>
+        <button className="sm ghost danger" onClick={() => setShowResetModal(true)}>
+          {t('config.resetConfig')}
+        </button>
+      </div>
+
+      {showResetModal && (
+        <div className="shell-modal-overlay" onClick={() => setShowResetModal(false)}>
+          <div className="shell-modal" onClick={e => e.stopPropagation()}>
+            <div className="shell-modal-header" style={{ color: 'var(--danger)' }}>
+              <AlertTriangle size={16} style={{ verticalAlign: 'middle', marginRight: 8 }} />
+              {t('config.resetConfig')}
            </div>
-            <div style={{ display: 'flex', gap: 8 }}>
-              <button className="sm" onClick={() => setResetConfirm(false)}>{t('config.cancel')}</button>
-              <button className="sm danger" onClick={handleReset}>{t('config.resetConfig')}</button>
+            <div className="shell-modal-body">
+              <p style={{ color: 'var(--warning)', fontSize: 13, marginBottom: 12 }}>
+                {t('config.resetConfirm')}
+              </p>
+              <p style={{ color: 'var(--text-tertiary)', fontSize: 12 }}>
+                Cette action est irréversible. Toute votre configuration (profil, clés API, préférences) sera supprimée.
+              </p>
+            </div>
+            <div className="shell-modal-footer">
+              <button className="ghost" onClick={() => setShowResetModal(false)}>{t('config.cancel')}</button>
+              <button className="danger" onClick={handleReset}>{t('config.resetConfig')}</button>
            </div>
          </div>
-        ) : (
-          <button className="sm ghost danger" onClick={() => setResetConfirm(true)}>
-            {t('config.resetConfig')}
-          </button>
-        )}
-      </div>
+        </div>
+      )}
    </>
  )
 }
--- a/web/src/components/Dashboard.jsx
+++ b/web/src/components/Dashboard.jsx
@@ -3,6 +3,9 @@ import { useI18n } from '../i18n'

 const MAX_POINTS = 30

+const POLL_INTERVAL = 5000
+const MAX_IDLE_POLLS = 3
+
 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)
@@ -40,6 +43,7 @@ export default function Dashboard({ api, refreshRef }) {
  const [recentCmds, setRecentCmds] = useState([])
  const [processes, setProcesses] = useState([])
  const [metrics, setMetrics] = useState(null)
+  const [copiedIdx, setCopiedIdx] = useState(-1)
  const cpuRef = useRef([])
  const memRef = useRef([])
  const netRxRef = useRef([])
@@ -71,13 +75,40 @@ export default function Dashboard({ api, refreshRef }) {
  useEffect(() => {
    loadData()
    if (refreshRef) refreshRef.current = loadData
-    const iv = setInterval(loadData, 5000)
-    return () => clearInterval(iv)
+    let active = true
+    let idleTicks = 0
+    const iv = setInterval(() => {
+      const hidden = document.querySelector('.dash-grid')?.closest('.tab-hidden')
+      if (hidden) {
+        idleTicks++
+        if (idleTicks >= MAX_IDLE_POLLS) return
+      } else {
+        idleTicks = 0
+      }
+      if (active) loadData()
+    }, POLL_INTERVAL)
+    return () => { active = false; clearInterval(iv) }
  }, [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']
+
+  const topCmds = (() => {
+    const counts = {}
+    for (const c of recentCmds) {
+      const base = c.cmd.split(/\s+/)[0]
+      if (!base || base.length < 2 || EXCLUDE_CMDS.includes(base)) continue
+      if (!/^[a-zA-Z@.\/]/.test(base)) continue
+      counts[base] = (counts[base] || 0) + 1
+    }
+    return Object.entries(counts)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5)
+      .map(([cmd, count]) => ({ cmd, count }))
+  })()
+
  return (
    <div className="dash-grid">
      {/* CPU */}
@@ -129,10 +160,19 @@ export default function Dashboard({ api, refreshRef }) {
              <span className="dash-quota-val" style={{ color: 'var(--text-tertiary)' }}>{minimax.error || 'no data'}</span>
            </div>
          )}
-          {zai && (
+          {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">{zai.healthy ? '✓ active' : zai.error || '—'}</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>}
@@ -161,6 +201,16 @@ export default function Dashboard({ api, refreshRef }) {
        <div className="dash-card-head">
          <span className="dash-label">Recent Commands</span>
        </div>
+        {topCmds.length > 0 && (
+          <div className="dash-cmd-top">
+            {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>
+            ))}
+          </div>
+        )}
        <div className="dash-cmd-list">
          {recentCmds.length === 0 && <span className="dash-empty">No history</span>}
          {recentCmds.map((c, i) => (
--- a/web/src/components/Shell.jsx
+++ b/web/src/components/Shell.jsx
@@ -2,11 +2,70 @@ import { useState, useRef, useEffect, useCallback } from 'react'
 import { Terminal as XTerm } from '@xterm/xterm'
 import { FitAddon } from '@xterm/addon-fit'
 import { WebLinksAddon } from '@xterm/addon-web-links'
-import { Plus, X, Monitor, Globe, ChevronDown, Pencil, Trash2 } from 'lucide-react'
+import { Plus, X, Monitor, Globe, ChevronDown, Pencil, Trash2, Search, Copy, Send, Eye } from 'lucide-react'
 import '@xterm/xterm/css/xterm.css'
 import { useI18n } from '../i18n'

 const MAX_TABS = 7
+const SHELL_MAX_TOKENS = 100000
+const TABS_STORAGE_KEY = 'muyue_shell_tabs'
+const TERMINAL_BUFFER_KEY = 'muyue_terminal_buffers'
+
+function renderContent(text) {
+  const parts = []
+  const codeBlockRegex = /(```[\s\S]*?```)/g
+  let match
+  let lastIndex = 0
+  while ((match = codeBlockRegex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      parts.push({ type: 'text', content: text.slice(lastIndex, match.index) })
+    }
+    const full = match[1]
+    const firstNewline = full.indexOf('\n')
+    const lang = firstNewline > -1 ? full.slice(3, firstNewline).trim() : ''
+    const code = firstNewline > -1 ? full.slice(firstNewline + 1, -3) : full.slice(3, -3)
+    parts.push({ type: 'code', lang, content: code })
+    lastIndex = match.index + full.length
+  }
+  if (lastIndex < text.length) {
+    const remaining = text.slice(lastIndex)
+    const openBlock = remaining.match(/```(\w*)\n?([\s\S]*)$/)
+    if (openBlock) {
+      if (openBlock.index > 0) {
+        parts.push({ type: 'text', content: remaining.slice(0, openBlock.index) })
+      }
+      parts.push({ type: 'code', lang: openBlock[1] || '', content: openBlock[2] || '' })
+    } else {
+      parts.push({ type: 'text', content: remaining })
+    }
+  }
+  return parts
+}
+
+function formatText(text) {
+  let html = text
+    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+
+  html = html
+    .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
+    .replace(/`([^`]+)`/g, '<code class="inline-code">$1</code>')
+    .replace(/^### (.+)$/gm, '<h4 class="msg-h4">$1</h4>')
+    .replace(/^## (.+)$/gm, '<h3 class="msg-h3">$1</h3>')
+    .replace(/^# (.+)$/gm, '<h2 class="msg-h2">$1</h2>')
+    .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(/\s+on\w+=["'][^"']*["']/gi, '')
+    .replace(/javascript:/gi, '')
+    .replace(/data:/gi, '')
+
+  return html
+}

 const THEMES = {
  default: {
@@ -73,7 +132,7 @@ function createTerminal(container, settings = {}) {
  const theme = getTheme(settings.theme || 'default')
  const term = new XTerm({
    cursorBlink: true,
-    fontSize: settings.fontSize || 14,
+    fontSize: settings.fontSize || 12,
    fontFamily: settings.fontFamily || "'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'SF Mono', 'Menlo', monospace",
    theme,
    allowTransparency: false,
@@ -90,7 +149,7 @@ function createTerminal(container, settings = {}) {
  return { term, fitAddon }
 }

-function connectWebSocket(term, fitAddon, initPayload) {
+function connectWebSocket(term, fitAddon, initPayload, onStateChange, onFirstMessage) {
  const proto = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
  const ws = new WebSocket(`${proto}//${window.location.host}/api/ws/terminal`)

@@ -100,9 +159,15 @@ function connectWebSocket(term, fitAddon, initPayload) {
    if (dims) {
      ws.send(JSON.stringify({ type: 'resize', rows: dims.rows, cols: dims.cols }))
    }
+    if (onStateChange) onStateChange(true)
  })

+  let firstMessage = true
  ws.addEventListener('message', (event) => {
+    if (firstMessage) {
+      firstMessage = false
+      if (onFirstMessage) onFirstMessage()
+    }
    try {
      const msg = JSON.parse(event.data)
      if (msg.type === 'output') {
@@ -117,16 +182,12 @@ function connectWebSocket(term, fitAddon, initPayload) {

  ws.addEventListener('close', () => {
    term.write('\r\n\x1b[33m— Connection closed —\x1b[0m\r\n')
+    if (onStateChange) onStateChange(false)
  })

  ws.addEventListener('error', () => {
    term.write('\r\n\x1b[31m— Connection error —\x1b[0m\r\n')
-  })
-
-  term.onData((data) => {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: 'input', data }))
-    }
+    if (onStateChange) onStateChange(false)
  })

  term.onResize(({ rows, cols }) => {
@@ -142,11 +203,34 @@ export default function Shell({ api }) {
  const { t } = useI18n()
  const tabsRef = useRef({})
  const nextIdRef = useRef(1)
+  const settingsRef = useRef({ fontSize: 12, fontFamily: "'JetBrains Mono', 'Fira Code', monospace", theme: 'default' })
+  const activeTabRef = useRef(null)
+  const pendingCommandsRef = useRef({})

-  const [tabs, setTabs] = useState([
+  useEffect(() => { activeTabRef.current = activeTab }, [activeTab])
+
+  const savedTabs = (() => {
+    try {
+      const raw = localStorage.getItem(TABS_STORAGE_KEY)
+      if (raw) {
+        const parsed = JSON.parse(raw)
+        if (Array.isArray(parsed) && parsed.length > 0) {
+          return parsed.map(t => ({ ...t, connected: false }))
+        }
+      }
+    } catch {}
+    return null
+  })()
+
+  const [tabs, setTabs] = useState(savedTabs || [
    { id: 1, name: 'Local Shell', type: 'local', shell: '', connected: false },
  ])
-  const [activeTab, setActiveTab] = useState(1)
+  const [activeTab, setActiveTab] = useState(() => {
+    if (savedTabs) {
+      return savedTabs[0]?.id || 1
+    }
+    return 1
+  })
  const [sshConnections, setSshConnections] = useState([])
  const [systemTerminals, setSystemTerminals] = useState([])
  const [showMenu, setShowMenu] = useState(false)
@@ -154,26 +238,63 @@ export default function Shell({ api }) {
  const [editingTab, setEditingTab] = useState(null)
  const [editName, setEditName] = useState('')
  const [terminalSettings, setTerminalSettings] = useState({
-    fontSize: 14,
+    fontSize: 12,
    fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'SF Mono', 'Menlo', monospace",
    theme: 'default',
  })

+  useEffect(() => { settingsRef.current = terminalSettings }, [terminalSettings])
+
  const [sshForm, setSshForm] = useState({
    name: '', host: '', port: 22, user: '', key_path: '',
  })

-  const [aiMessages, setAiMessages] = useState([
-    { role: 'ai', content: t('shell.aiWelcome') }
-  ])
+  const [aiMessages, setAiMessages] = useState([])
  const [aiInput, setAiInput] = useState('')
  const [aiLoading, setAiLoading] = useState(false)
+  const [aiTokens, setAiTokens] = useState(0)
+  const [aiAtLimit, setAiAtLimit] = useState(false)
+  const [analyzing, setAnalyzing] = useState(false)
+  const [showAnalysis, setShowAnalysis] = useState(false)
+  const [analysisContent, setAnalysisContent] = useState('')
  const aiMessagesRef = useRef(null)
+  const aiLoadedRef = useRef(false)
+  const aiLoadingRef = useRef(false)

  useEffect(() => {
    aiMessagesRef.current?.scrollTo(0, aiMessagesRef.current.scrollHeight)
  }, [aiMessages])

+  useEffect(() => {
+    api.getShellAnalysis?.().then(d => {
+      if (d?.analysis) setAnalysisContent(d.analysis)
+    }).catch(() => {
+      const stored = localStorage.getItem('shell_analysis')
+      if (stored) setAnalysisContent(stored)
+    })
+  }, [])
+
+  useEffect(() => {
+    if (aiLoadedRef.current) return
+    aiLoadedRef.current = true
+    api.getShellChatHistory().then(d => {
+      if (d.messages && d.messages.length > 0) {
+        setAiMessages(d.messages)
+      } else {
+        setAiMessages([{ role: 'assistant', content: t('shell.aiWelcome') || 'Système Analyste prêt. Tapez /help pour les commandes.' }])
+      }
+      setAiTokens(d.tokens || 0)
+      setAiAtLimit(d.at_limit || false)
+    }).catch(() => {
+      setAiMessages([{ role: 'assistant', content: 'Système Analyste prêt.' }])
+    })
+  }, [])
+
+  useEffect(() => {
+    const maxId = tabs.reduce((max, t) => Math.max(max, t.id), 0)
+    nextIdRef.current = maxId + 1
+  }, [])
+
  useEffect(() => {
    api.getTerminalSessions().then(d => {
      setSshConnections(d.ssh || [])
@@ -182,7 +303,7 @@ export default function Shell({ api }) {
    api.getConfig().then(d => {
      if (d.terminal) {
        setTerminalSettings({
-          fontSize: d.terminal.font_size || 14,
+          fontSize: d.terminal.font_size || 12,
          fontFamily: d.terminal.font_family || "'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'SF Mono', 'Menlo', monospace",
          theme: d.terminal.theme || 'default',
        })
@@ -196,10 +317,11 @@ export default function Shell({ api }) {
    const container = document.getElementById(`terminal-${tabId}`)
    if (!container) return

+    const s = settingsRef.current
    const { term, fitAddon } = createTerminal(container, {
-      fontSize: terminalSettings.fontSize,
-      fontFamily: terminalSettings.fontFamily,
-      theme: terminalSettings.theme,
+      fontSize: s.fontSize,
+      fontFamily: s.fontFamily,
+      theme: s.theme,
    })

    let initPayload
@@ -220,20 +342,63 @@ export default function Shell({ api }) {
      }
    }

-    const ws = connectWebSocket(term, fitAddon, initPayload)
+    let disposed = false

-    ws.onopen = () => {
-      setTabs(prev => prev.map(t => t.id === tabId ? { ...t, connected: true } : t))
+    const saveBuffer = () => {
+      try {
+        const buf = term.buffer.active
+        const lines = []
+        for (let i = 0; i < buf.length; i++) {
+          const line = buf.getLine(i)
+          if (line) lines.push(line.translateToString(true))
+        }
+        const savedBuffers = JSON.parse(sessionStorage.getItem(TERMINAL_BUFFER_KEY) || '{}')
+        savedBuffers[tabId] = lines.join('\n')
+        sessionStorage.setItem(TERMINAL_BUFFER_KEY, JSON.stringify(savedBuffers))
+      } catch (e) { console.warn('[Shell] Buffer save failed:', e) }
    }

-    ws.onclose = () => {
-      setTabs(prev => prev.map(t => t.id === tabId ? { ...t, connected: false } : t))
+    const onWsState = (connected) => {
+      if (disposed) return
+      if (!connected) saveBuffer()
+      setTabs(prev => prev.map(t => t.id === tabId ? { ...t, connected } : t))
    }

-    ws.onerror = () => {
-      setTabs(prev => prev.map(t => t.id === tabId ? { ...t, connected: false } : t))
+    const restoreBuffer = () => {
+      try {
+        const savedBuffers = JSON.parse(sessionStorage.getItem(TERMINAL_BUFFER_KEY) || '{}')
+        if (savedBuffers[tabId]) {
+          term.write('\x1b[90m— session restaurée —\x1b[0m\r\n')
+          term.write(savedBuffers[tabId])
+        }
+      } catch (e) { console.warn('[Shell] Buffer restore failed:', e) }
    }

+    const ws = connectWebSocket(term, fitAddon, initPayload, onWsState, restoreBuffer)
+
+    const clearBufferOnClear = () => {
+      try {
+        const buf = term.buffer.active
+        const lineY = buf.length - 1
+        const line = buf.getLine(lineY)
+        if (line) {
+          const text = line.translateToString(true).trim().toLowerCase()
+          if (text === 'clear' || text === '$ clear' || text.endsWith(' clear')) {
+            const savedBuffers = JSON.parse(sessionStorage.getItem(TERMINAL_BUFFER_KEY) || '{}')
+            delete savedBuffers[tabId]
+            sessionStorage.setItem(TERMINAL_BUFFER_KEY, JSON.stringify(savedBuffers))
+          }
+        }
+      } catch (e) { console.warn('[Shell] Clear detection failed:', e) }
+    }
+
+    term.onData((data) => {
+      if (data === '\r') clearBufferOnClear()
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'input', data }))
+      }
+    })
+
    const onResize = () => {
      const el = document.getElementById(`terminal-${tabId}`)
      if (el && el.offsetParent !== null) {
@@ -245,37 +410,104 @@ export default function Shell({ api }) {
    resizeObserver.observe(container)
    window.addEventListener('resize', onResize)

-    tabsRef.current[tabId] = { term, fitAddon, ws, resizeObserver, onResize }
+    const bufferSaveInterval = setInterval(() => { if (!disposed) saveBuffer() }, 5000)
+
+    console.log(`[Shell] initTerminal tab=${tabId} type=${tab.type} name="${tab.name}" shell="${tab.shell || '(default)'}"`)
+    tabsRef.current[tabId] = { term, fitAddon, ws, resizeObserver, onResize, bufferSaveInterval, saveBuffer, disposed: () => disposed }
+    tabsRef.current[tabId]._markDisposed = () => { disposed = true }
+    console.log(`[Shell] initTerminal tab=${tabId} done, tabsRef keys:`, Object.keys(tabsRef.current))
+
+    const pending = pendingCommandsRef.current[tabId]
+    if (pending && pending.length > 0) {
+      console.log(`[Shell] Flushing ${pending.length} pending commands for tab ${tabId}`)
+      for (const cmd of pending) {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'input', data: cmd + '\r' }))
+        }
+      }
+      delete pendingCommandsRef.current[tabId]
+    }
  }, [])

  useEffect(() => {
    const tab = tabs.find(t => t.id === activeTab)
    if (!tab) return

-    const container = document.getElementById(`terminal-${tab.id}`)
-    if (!container) return
+    let cancelled = false
+    const pending = []

-    if (!tabsRef.current[tab.id]) {
-      const timer = setTimeout(() => {
+    const tryInit = (attempt) => {
+      if (cancelled || attempt > 20) return
+      const shellCol = document.querySelector('.shell-terminal-col')
+      if (!shellCol || shellCol.offsetParent === null) {
+        pending.push(setTimeout(() => tryInit(attempt + 1), 150))
+        return
+      }
+      const container = document.getElementById(`terminal-${tab.id}`)
+      if (!container || container.offsetHeight === 0) {
+        pending.push(setTimeout(() => tryInit(attempt + 1), 100))
+        return
+      }
+      if (!tabsRef.current[tab.id]) {
        initTerminal(tab.id, tab)
-        requestAnimationFrame(() => {
-          const entry = tabsRef.current[tab.id]
-          if (entry) entry.fitAddon.fit()
-        })
-      }, 100)
-      return () => clearTimeout(timer)
-    } else {
+      }
      requestAnimationFrame(() => {
+        if (cancelled) return
        const entry = tabsRef.current[tab.id]
        if (entry) entry.fitAddon.fit()
      })
    }
+
+    tryInit(0)
+    return () => {
+      cancelled = true
+      pending.forEach(clearTimeout)
+    }
  }, [activeTab, tabs, initTerminal])

+  useEffect(() => {
+    const iv = setInterval(() => {
+      for (const tab of tabs) {
+        const entry = tabsRef.current[tab.id]
+        if (entry) {
+          const el = document.getElementById(`terminal-${tab.id}`)
+          if (el && el.offsetParent !== null) {
+            entry.fitAddon.fit()
+          }
+        }
+      }
+    }, 2000)
+    return () => clearInterval(iv)
+  }, [tabs])
+
+  useEffect(() => {
+    return () => {
+      for (const [tabId, entry] of Object.entries(tabsRef.current)) {
+        entry._markDisposed?.()
+        if (entry.bufferSaveInterval) clearInterval(entry.bufferSaveInterval)
+        window.removeEventListener('resize', entry.onResize)
+        entry.resizeObserver?.disconnect()
+        entry.ws?.close()
+        entry.term?.dispose()
+      }
+      tabsRef.current = {}
+    }
+  }, [])
+
  useEffect(() => {
    const onKey = (e) => {
      if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA') return
-      if (!e.altKey) return
+      if (!e.altKey && !(e.key === 'Tab' && e.shiftKey)) return
+
+      if (e.key === 'Tab' && e.shiftKey) {
+        const shellTab = document.querySelector('.shell-layout')
+        if (!shellTab || shellTab.closest('.tab-hidden')) return
+        e.preventDefault()
+        const idx = tabs.findIndex(t => t.id === activeTab)
+        const next = (idx + 1) % tabs.length
+        setActiveTab(tabs[next].id)
+        return
+      }

      const num = parseInt(e.key)
      if (num >= 1 && num <= tabs.length) {
@@ -290,8 +522,8 @@ export default function Shell({ api }) {
  const addLocalTab = (shell, name) => {
    if (tabs.length >= MAX_TABS) return
    const id = nextIdRef.current++
-    const newTab = { id, name: name || `${t('shell.localShell')} ${tabs.length + 1}`, type: 'local', shell: shell || '', connected: false }
-    setTabs(prev => [...prev, newTab])
+    const newTab = { id, name: name || `${t('shell.localShell')} ${tabs.length}`, type: 'local', shell: shell || '', connected: false }
+    setTabs(prev => { const next = [...prev, newTab]; localStorage.setItem(TABS_STORAGE_KEY, JSON.stringify(next.map(t => ({ id: t.id, name: t.name, type: t.type, shell: t.shell, host: t.host, port: t.port, user: t.user, key_path: t.key_path })))); return next })
    setActiveTab(id)
    setShowMenu(false)
  }
@@ -309,25 +541,34 @@ export default function Shell({ api }) {
      key_path: conn.key_path || '',
      connected: false,
    }
-    setTabs(prev => [...prev, newTab])
+    setTabs(prev => { const next = [...prev, newTab]; localStorage.setItem(TABS_STORAGE_KEY, JSON.stringify(next.map(t => ({ id: t.id, name: t.name, type: t.type, shell: t.shell, host: t.host, port: t.port, user: t.user, key_path: t.key_path })))); return next })
    setActiveTab(id)
    setShowMenu(false)
  }

  const closeTab = (tabId, e) => {
    if (e) e.stopPropagation()
-    if (tabs.length <= 1) return

-    if (tabsRef.current[tabId]) {
-      const { ws, resizeObserver, onResize, term } = tabsRef.current[tabId]
-      window.removeEventListener('resize', onResize)
-      resizeObserver.disconnect()
-      ws.close()
-      term.dispose()
+    const entry = tabsRef.current[tabId]
+    if (entry) {
+      entry._markDisposed?.()
+      entry.saveBuffer?.()
+      if (entry.bufferSaveInterval) clearInterval(entry.bufferSaveInterval)
+      window.removeEventListener('resize', entry.onResize)
+      entry.resizeObserver.disconnect()
+      entry.ws.close()
+      entry.term.dispose()
      delete tabsRef.current[tabId]
    }

+    try {
+      const savedBuffers = JSON.parse(sessionStorage.getItem(TERMINAL_BUFFER_KEY) || '{}')
+      delete savedBuffers[tabId]
+      sessionStorage.setItem(TERMINAL_BUFFER_KEY, JSON.stringify(savedBuffers))
+    } catch (e) { console.warn('[Shell] Buffer cleanup failed:', e) }
+
    setTabs(prev => {
+      if (prev.length <= 1) return prev
      const next = prev.filter(t => t.id !== tabId)
      if (activeTab === tabId && next.length > 0) {
        setActiveTab(next[next.length - 1].id)
@@ -372,55 +613,123 @@ export default function Shell({ api }) {
    }
  }

-  const handleAiSend = async () => {
-    if (!aiInput.trim() || aiLoading) return
-    const text = aiInput.trim()
-    setAiMessages(prev => [...prev, { role: 'user', content: text }])
-    setAiInput('')
-    setAiLoading(true)
-
-    const currentTab = tabs.find(t => t.id === activeTab)
-    const context = {
-      cwd: currentTab?.cwd || '',
-      platform: navigator.platform || '',
+  const sendToTerminal = useCallback((code, tabId) => {
+    const targetId = tabId || activeTabRef.current
+    const entry = tabsRef.current[targetId]
+    if (!entry) {
+      console.warn(`[Shell] sendToTerminal: tab ${targetId} not ready. Queueing. tabsRef:`, Object.keys(tabsRef.current), 'activeTab:', activeTabRef.current, 'requested:', tabId)
+      if (!pendingCommandsRef.current[targetId]) pendingCommandsRef.current[targetId] = []
+      pendingCommandsRef.current[targetId].push(code)
+      return
    }
+    if (!entry.ws || entry.ws.readyState !== WebSocket.OPEN) {
+      console.warn(`[Shell] sendToTerminal: WS not open for tab ${targetId} (state=${entry.ws?.readyState}). Queueing.`)
+      if (!pendingCommandsRef.current[targetId]) pendingCommandsRef.current[targetId] = []
+      pendingCommandsRef.current[targetId].push(code)
+      return
+    }
+    console.log(`[Shell] sendToTerminal: tab ${targetId} ← ${code.length} chars`)
+    entry.ws.send(JSON.stringify({ type: 'input', data: code + '\r' }))
+  }, [])
+
+  const focusAiTerminal = useCallback(() => {
+    const entry = tabsRef.current[activeTabRef.current]
+    if (entry) entry.term.focus()
+  }, [])
+
+  const _sendAiMessage = useCallback(async (text, fromEvent = false) => {
+    if (!text || !text.trim() || aiLoadingRef.current || aiAtLimit) return
+    const trimmed = text.trim()
+    aiLoadingRef.current = true
+
+    if (!fromEvent) {
+      setAiInput('')
+      focusAiTerminal()
+    }
+
+    if (trimmed === '/clear') {
+      try {
+        await api.clearShellChat()
+        setAiMessages([{ role: 'assistant', content: t('shell.aiWelcome') || 'Contexte effacé. Prêt.' }])
+        setAiTokens(0)
+        setAiAtLimit(false)
+      } catch {}
+      aiLoadingRef.current = false
+      return
+    }
+
+    if (trimmed === '/help') {
+      setAiMessages(prev => [...prev,
+        { role: 'user', content: trimmed },
+        { role: 'assistant', content: 'Commandes disponibles:\n• /clear — Effacer la conversation\n• /help — Afficher l\'aide\n\nJe ne peux pas exécuter de code. Les blocs de code proposés peuvent être copiés ou envoyés directement au terminal actif.' }
+      ])
+      aiLoadingRef.current = false
+      return
+    }
+
+    const currentTab = activeTabRef.current
+    console.log(`[Shell] _sendAiMessage: activeTab=${currentTab}, fromEvent=${fromEvent}, text="${trimmed.slice(0, 50)}"`)
+    setAiMessages(prev => [...prev, { role: 'user', content: trimmed, _tabId: currentTab }])
+    setAiLoading(true)

    try {
      let accumulated = ''
-      await api.sendShellChat(text, context, true, (partial, event) => {
-        if (event && event.tool_call) {
-          setAiMessages(prev => [...prev, {
-            role: 'tool',
-            content: `${t('shell.toolLaunched')}: ${event.tool_call.name || 'tool'}`,
-            args: event.tool_call.args ? JSON.stringify(event.tool_call.args).slice(0, 100) : '',
-          }])
-          return
-        }
-        if (event && event.tool_result) {
-          const resultText = event.tool_result.result?.content || event.tool_result.error || 'completed'
-          setAiMessages(prev => [...prev, {
-            role: 'tool_result',
-            content: resultText,
-            isError: event.tool_result.result?.is_error,
-          }])
-          return
-        }
-        if (event && event.done) return
+      await api.sendShellChat(trimmed, {}, true, (partial) => {
        accumulated = partial
        setAiMessages(prev => {
          const filtered = prev.filter(m => !m._streaming)
-          return [...filtered, { role: 'ai', content: partial, _streaming: true }]
+          return [...filtered, { role: 'assistant', content: partial, _streaming: true, _tabId: currentTab }]
        })
      })

-      setAiMessages(prev => prev.filter(m => !m._streaming))
-      if (accumulated) {
-        setAiMessages(prev => [...prev.filter(m => !m._streaming), { role: 'ai', content: accumulated }])
-      }
+      setAiMessages(prev => {
+        const filtered = prev.filter(m => !m._streaming)
+        return [...filtered, { role: 'assistant', content: accumulated, _tabId: currentTab }]
+      })
+      api.getShellChatHistory().then(d => {
+        setAiTokens(d.tokens || 0)
+        setAiAtLimit(d.at_limit || false)
+      }).catch(() => {})
    } catch (err) {
-      setAiMessages(prev => [...prev.filter(m => !m._streaming), { role: 'ai', content: `${t('shell.error')}: ${err.message}` }])
+      if (err.message?.includes('context limit')) {
+        setAiAtLimit(true)
+      }
+      setAiMessages(prev => [...prev.filter(m => !m._streaming), { role: 'assistant', content: `Erreur: ${err.message}` }])
    }
    setAiLoading(false)
+    aiLoadingRef.current = false
+  }, [api, t, aiAtLimit, focusAiTerminal])
+
+  const handleAiSend = () => _sendAiMessage(aiInput, false)
+
+  useEffect(() => {
+    const handler = (e) => {
+      const msg = e.detail?.message
+      if (!msg) return
+      setAiInput(msg)
+      setTimeout(() => _sendAiMessage(msg, true), 100)
+    }
+    window.addEventListener('ask-ai-terminal', handler)
+    return () => window.removeEventListener('ask-ai-terminal', handler)
+  }, [_sendAiMessage])
+
+  const handleAnalyze = async () => {
+    setAnalyzing(true)
+    setAiMessages(prev => [...prev, { role: 'system', content: 'Analyse du système en cours...' }])
+    try {
+      const d = await api.analyzeSystem()
+      if (d.analysis) {
+        setAnalysisContent(d.analysis)
+        localStorage.setItem('shell_analysis', d.analysis)
+      }
+      setAiMessages(prev => [...prev.filter(m => m.content !== 'Analyse du système en cours...'), {
+        role: 'system',
+        content: 'Analyse système terminée et sauvegardée. Le contexte système est maintenant disponible.'
+      }])
+    } catch (err) {
+      setAiMessages(prev => prev.filter(m => m.content !== 'Analyse du système en cours...'))
+    }
+    setAnalyzing(false)
  }

  return (
@@ -538,13 +847,41 @@ export default function Shell({ api }) {
      </div>

      <div className="shell-ai-col">
-        <div className="ai-panel-header">{t('shell.aiAssistant')}</div>
+        <div className="ai-panel-header">
+          <span>Analyste Système</span>
+          <div style={{ display: 'flex', gap: 6 }}>
+            <button
+              className="shell-analyze-btn"
+              onClick={() => setShowAnalysis(true)}
+              disabled={!analysisContent}
+              title="Voir l'analyse"
+            >
+              <Eye size={13} />
+              Analyse
+            </button>
+            <button
+              className="shell-analyze-btn"
+              onClick={handleAnalyze}
+              disabled={analyzing}
+              title="Analyser le système"
+            >
+              <Search size={13} />
+              {analyzing ? '...' : 'Analyser'}
+            </button>
+          </div>
+        </div>
+        <div className="shell-ai-token-bar">
+          <div className="shell-ai-token-track">
+            <div
+              className={`shell-ai-token-fill ${aiTokens >= SHELL_MAX_TOKENS * 0.8 ? 'warn' : ''}`}
+              style={{ width: `${Math.min(100, (aiTokens / SHELL_MAX_TOKENS) * 100)}%` }}
+            />
+          </div>
+          <span className="shell-ai-token-text">{Math.round(aiTokens / 1000)}k/{Math.round(SHELL_MAX_TOKENS / 1000)}k</span>
+        </div>
        <div className="ai-panel-messages" ref={aiMessagesRef}>
          {aiMessages.map((msg, i) => (
-            <div key={i} className={`ai-message ${msg.role}`}>
-              {msg.content}
-              {msg.args && <div className="tool-args">{msg.args}</div>}
-            </div>
+            <ShellAIMessage key={i} msg={msg} sendToTerminal={sendToTerminal} terminalTabId={msg._tabId || activeTab} />
          ))}
          {aiLoading && <div style={{ textAlign: 'center', padding: 8 }}><span className="spinner" /></div>}
        </div>
@@ -553,12 +890,36 @@ export default function Shell({ api }) {
            value={aiInput}
            onChange={e => setAiInput(e.target.value)}
            onKeyDown={e => e.key === 'Enter' && handleAiSend()}
-            placeholder={t('shell.askAi')}
+            placeholder={aiAtLimit ? '/clear pour continuer' : t('shell.askAi')}
+            disabled={aiAtLimit && aiInput !== '/clear'}
          />
-          <button className="sm" onClick={handleAiSend} disabled={!aiInput.trim()}>{t('shell.send')}</button>
+          <button className="sm" onClick={handleAiSend} disabled={(!aiInput.trim() && !aiAtLimit) || (aiAtLimit && aiInput !== '/clear')}>{t('shell.send')}</button>
        </div>
      </div>

+      {showAnalysis && analysisContent && (
+        <div className="shell-modal-overlay" onClick={() => setShowAnalysis(false)}>
+          <div className="shell-analysis-modal" onClick={e => e.stopPropagation()}>
+            <div className="shell-analysis-modal-header">
+              <span>Analyse Système</span>
+              <button className="shell-tab-close" onClick={() => setShowAnalysis(false)}><X size={16} /></button>
+            </div>
+            <div className="shell-analysis-modal-body">
+              {renderContent(analysisContent).map((part, i) =>
+                part.type === 'code' ? (
+                  <div key={i} className="shell-code-block">
+                    {part.lang && <div className="shell-code-lang">{part.lang}</div>}
+                    <pre><code>{part.content}</code></pre>
+                  </div>
+                ) : (
+                  <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
+                )
+              )}
+            </div>
+          </div>
+        </div>
+      )}
+
      {showSshModal && (
        <div className="shell-modal-overlay" onClick={() => setShowSshModal(false)}>
          <div className="shell-modal" onClick={e => e.stopPropagation()}>
@@ -611,3 +972,42 @@ export default function Shell({ api }) {
    </div>
  )
 }
+
+function ShellAIMessage({ msg, sendToTerminal, terminalTabId }) {
+  const role = msg.role === 'user' ? 'user' : msg.role === 'system' ? 'system' : 'assistant'
+  const content = msg.content || ''
+
+  if (role === 'user') {
+    return <div className={`ai-message user`}>{content}</div>
+  }
+
+  if (role === 'system') {
+    return <div className={`ai-message system`}>{content}</div>
+  }
+
+  const parts = renderContent(content)
+
+  return (
+    <div className={`ai-message assistant`}>
+      {parts.map((part, i) => {
+        if (part.type === 'code') {
+          return (
+            <div key={i} className="shell-code-block">
+              {part.lang && <div className="shell-code-lang">{part.lang}</div>}
+              <pre><code>{part.content}</code></pre>
+              <div className="shell-code-actions">
+                <button onClick={() => navigator.clipboard.writeText(part.content)} title="Copier">
+                  <Copy size={12} /> Copier
+                </button>
+                <button onClick={() => sendToTerminal(part.content, terminalTabId)} title="Envoyer au terminal">
+                  <Send size={12} /> Terminal
+                </button>
+              </div>
+            </div>
+          )
+        }
+        return <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
+      })}
+    </div>
+  )
+}
--- a/web/src/components/Studio.jsx
+++ b/web/src/components/Studio.jsx
@@ -1,4 +1,4 @@
-import { useState, useRef, useEffect, useCallback } from 'react'
+import { useState, useRef, useEffect, useCallback, useMemo } from 'react'
 import { useI18n } from '../i18n'

 const RANKS = {
@@ -47,17 +47,24 @@ function renderContent(text) {
    lastIndex = match.index + full.length
  }
  if (lastIndex < text.length) {
-    parts.push({ type: 'text', content: text.slice(lastIndex) })
+    const remaining = text.slice(lastIndex)
+    const openBlock = remaining.match(/```(\w*)\n?([\s\S]*)$/)
+    if (openBlock) {
+      if (openBlock.index > 0) {
+        parts.push({ type: 'text', content: remaining.slice(0, openBlock.index) })
+      }
+      parts.push({ type: 'code', lang: openBlock[1] || '', content: openBlock[2] || '' })
+    } else {
+      parts.push({ type: 'text', content: remaining })
+    }
  }
  return parts
 }

 function formatText(text) {
-  // First escape HTML entities
  let html = text
    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
  
-  // Apply markdown transformations (now with escaped brackets)
  html = html
    .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
    .replace(/`([^`]+)`/g, '<code class="inline-code">$1</code>')
@@ -66,17 +73,20 @@ function formatText(text) {
    .replace(/^# (.+)$/gm, '<h2 class="msg-h2">$1</h2>')
    .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/>')
  
-  // Sanitize: remove event handlers and dangerous protocols
  html = html
-    .replace(/\s+on\w+=["'][^"']*["']/gi, '') // Remove on* event handlers
+    .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(/\s+on\w+=["'][^"']*["']/gi, '')
    .replace(/javascript:/gi, '')
    .replace(/data:/gi, '')
  
  return html
 }

-function ThinkingBlock({ content, done }) {
+function ThinkingBlock({ content, done, raw }) {
  return (
    <div className={`feed-thinking-block ${done ? 'done' : 'active'}`}>
      <div className="feed-thinking-header">
@@ -86,7 +96,9 @@ function ThinkingBlock({ content, done }) {
        <span>Reflexion</span>
        {!done && <span className="feed-thinking-dots"><span/><span/><span/></span>}
      </div>
-      <div className="feed-thinking-content">{content}</div>
+      <div className="feed-thinking-content">
+        {raw ? <span dangerouslySetInnerHTML={{ __html: content }} /> : content}
+      </div>
    </div>
  )
 }
@@ -185,7 +197,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}`}>
@@ -200,7 +212,7 @@ function FeedItem({ msg }) {
          <span className="feed-role">{rank.label}</span>
          {timeStr && <span className="feed-time">{timeStr}</span>}
        </div>
-        {msg.thinking && <ThinkingBlock content={msg.thinking} done />}
+        {msg.thinking && <ThinkingBlock content={formatText(msg.thinking)} done raw />}
        {parsedToolCalls && parsedToolCalls.map((tc, i) => {
          const resultData = parsedToolResults
            ? parsedToolResults.find(r => r.tool_call_id === tc.tool_call_id)
@@ -234,6 +246,16 @@ function StreamingItem({ content, thinking, toolCalls }) {
  const cleanContent = content.replace(/<think[^>]*>[\s\S]*?<\/think>/gi, '')
  const hasToolCalls = toolCalls && toolCalls.length > 0

+  const renderedContent = useMemo(() => {
+    if (!cleanContent) return []
+    return renderContent(cleanContent)
+  }, [cleanContent])
+
+  const formattedThinking = useMemo(() => {
+    if (!thinking) return ''
+    return formatText(thinking)
+  }, [thinking])
+
  return (
    <div className="feed-item assistant">
      <div className="feed-avatar ai-rank">
@@ -246,7 +268,7 @@ function StreamingItem({ content, thinking, toolCalls }) {
          </span>
          <span className="feed-role">{rank.label}</span>
        </div>
-        {thinking && <ThinkingBlock content={thinking} done={false} />}
+        {thinking && <ThinkingBlock content={formattedThinking} raw done={false} />}
        {hasToolCalls && toolCalls.map((tc, i) => (
          <ToolCallBlock key={tc.call?.tool_call_id || i} call={tc.call} result={tc.result} />
        ))}
@@ -257,7 +279,7 @@ function StreamingItem({ content, thinking, toolCalls }) {
        )}
        {cleanContent && (
          <div className="feed-content">
-            {renderContent(cleanContent).map((part, i) =>
+            {renderedContent.map((part, i) =>
              part.type === 'code' ? (
                <div key={i} className="studio-code-block">
                  {part.lang && <div className="studio-code-lang">{part.lang}</div>}
@@ -288,6 +310,7 @@ export default function Studio({ api }) {
  const [contextCollapsed, setContextCollapsed] = useState(false)
  const [messagesCollapsed, setMessagesCollapsed] = useState(false)
  const messagesEnd = useRef(null)
+  const feedRef = useRef(null)
  const textareaRef = useRef(null)
  const abortRef = useRef(null)

@@ -318,6 +341,20 @@ export default function Studio({ api }) {
    messagesEnd.current?.scrollIntoView({ behavior: 'smooth' })
  }, [messages, streaming, streamThinking, streamToolCalls])

+  useEffect(() => {
+    const onTab = (e) => {
+      if (e.key !== 'Tab') return
+      if (document.activeElement?.tagName === 'INPUT' || document.activeElement?.tagName === 'TEXTAREA') return
+      const feed = document.querySelector('.studio-feed-layout')
+      if (!feed?.closest('.tab-hidden')) {
+        e.preventDefault()
+        textareaRef.current?.focus()
+      }
+    }
+    window.addEventListener('keydown', onTab)
+    return () => window.removeEventListener('keydown', onTab)
+  }, [])
+
  useEffect(() => {
    if (textareaRef.current) {
      textareaRef.current.style.height = 'auto'
@@ -367,6 +404,14 @@ export default function Studio({ api }) {
    const text = input.trim()
    setInput('')

+    const isSlashCommand = (t) => /^\/(clear|help|summarize|export|model(?:\s+\S+)?|plan\s+.+)$/.test(t)
+
+    if (text.startsWith('/') && !isSlashCommand(text)) {
+      setMessages(prev => [...prev, { id: Date.now().toString(), role: 'user', content: text, time: new Date().toISOString() }])
+      setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: 'Commande inconnue. Tapez `/help` pour la liste des commandes.', time: new Date().toISOString() }])
+      return
+    }
+
    if (text === '/clear') {
      handleClear()
      return
@@ -382,6 +427,7 @@ export default function Studio({ api }) {
        '- `/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',
@@ -401,14 +447,37 @@ export default function Studio({ api }) {
      return
    }

-    if (text === '/model') {
-      api.getProviders().then(data => {
-        const active = data.providers?.find(p => p.active)
-        const modelMsg = active ? active.name : 'Aucun provider actif configuré'
-        setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: modelMsg, time: new Date().toISOString() }])
-      }).catch(() => {
-        setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: 'Erreur: impossible de récupérer les providers', time: new Date().toISOString() }])
-      })
+    if (text === '/model' || text === '/model change') {
+      if (text === '/model change') {
+        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() }])
+            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
+          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(() => {
+            setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: 'Erreur lors du changement de provider.', time: new Date().toISOString() }])
+          })
+        }).catch(() => {
+          setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: 'Erreur: impossible de récupérer les providers', time: new Date().toISOString() }])
+        })
+      } else {
+        api.getProviders().then(data => {
+          const active = data.providers?.find(p => p.active)
+          const modelMsg = active ? `**${active.name}** — ${active.model}` : 'Aucun provider actif configuré'
+          setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: modelMsg, time: new Date().toISOString() }])
+        }).catch(() => {
+          setMessages(prev => [...prev, { id: Date.now().toString(), role: 'assistant', content: 'Erreur: impossible de récupérer les providers', time: new Date().toISOString() }])
+        })
+      }
      return
    }

@@ -463,6 +532,8 @@ 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) {
@@ -489,6 +560,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])
@@ -526,10 +602,38 @@ export default function Studio({ api }) {
    }
  }, [])

+  const COMMANDS = ['/clear', '/summarize', '/help', '/plan', '/export', '/model', '/model change']
+
  const handleKeyDown = (e) => {
    if (e.key === 'Enter' && !e.shiftKey) {
      e.preventDefault()
      handleSend()
+      return
+    }
+    if (e.key === 'Tab') {
+      e.preventDefault()
+      const ta = textareaRef.current
+      if (!ta) return
+      if (document.activeElement !== ta) {
+        ta.focus()
+        return
+      }
+      const val = ta.value
+      const pos = ta.selectionStart
+      const before = val.slice(0, pos)
+      const afterSlash = before.match(/\/[\w ]*$/)
+      if (afterSlash) {
+        const partial = afterSlash[0]
+        const matches = COMMANDS.filter(c => c.startsWith(partial) && c !== partial)
+        if (matches.length === 1) {
+          const completed = matches[0] + ' '
+          const newText = val.slice(0, pos - afterSlash[0].length) + completed + val.slice(pos)
+          setInput(newText)
+          requestAnimationFrame(() => {
+            ta.selectionStart = ta.selectionEnd = pos - afterSlash[0].length + completed.length
+          })
+        }
+      }
    }
  }

@@ -575,12 +679,22 @@ export default function Studio({ api }) {

  return (
    <div className="studio-feed-layout">
-      <div className="studio-feed">
-        {renderMessages()}
-        {(streaming || streamThinking || loading || streamToolCalls.length > 0) && (
-          <StreamingItem content={streaming} thinking={streamThinking} toolCalls={streamToolCalls} />
-        )}
-        <div ref={messagesEnd} style={{ height: '24px' }} />
+      <div className="studio-feed-scroll-wrap">
+        <div className="studio-feed" ref={feedRef}>
+          {renderMessages()}
+          {(streaming || streamThinking || loading || streamToolCalls.length > 0) && (
+            <StreamingItem content={streaming} thinking={streamThinking} toolCalls={streamToolCalls} />
+          )}
+          <div ref={messagesEnd} style={{ height: '24px' }} />
+        </div>
+        <div className="studio-scroll-btns">
+          <button className="studio-scroll-btn" onClick={() => feedRef.current?.scrollTo({ top: 0, behavior: 'smooth' })} title="Remonter">
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2"><path d="M18 15l-6-6-6 6"/></svg>
+          </button>
+          <button className="studio-scroll-btn" onClick={() => messagesEnd.current?.scrollIntoView({ behavior: 'smooth' })} title="Descendre">
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2"><path d="M6 9l6 6 6-6"/></svg>
+          </button>
+        </div>
      </div>

      <div className="studio-input-area">
@@ -630,7 +744,7 @@ export default function Studio({ api }) {
          )}
        </div>
        <div className="studio-input-hint">
-          {t('studio.inputHint')} · /clear /summarize /help /plan /export /model
+          {t('studio.inputHint')} · /clear /summarize /help /plan /export /model /model change
        </div>
      </div>
    </div>
--- a/web/src/i18n/fr.js
+++ b/web/src/i18n/fr.js
@@ -136,7 +136,7 @@ const fr = {
      terminal: 'Terminal',
      updates: 'Mises \u00e0 jour',
      locale: 'Langue & Clavier',
-      skills: 'Comp\u00e9ENCES',
+      skills: 'Compétences',
      system: 'Syst\u00e8me',
    },
    profile: 'Profil',
@@ -160,7 +160,7 @@ const fr = {
    save: 'Enregistrer',
    saved: 'Enregistr\u00e9 !',
    error: 'Erreur',
-    skills: 'Comp\u00e9ENCES',
+    skills: 'Compétences',
    noSkills: 'Aucune comp\u00e9tence install\u00e9e.',
    runSkillsInit: 'Ex\u00e9cutez muyue skills init',
    language: 'Langue',
--- a/web/src/styles/global.css
+++ b/web/src/styles/global.css
@@ -154,7 +154,9 @@ 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; }
+.content { flex: 1; overflow: hidden; position: relative; }
+.content > div { height: 100%; }
+.tab-hidden { display: none; }

 .statusbar {
  height: 28px;
@@ -391,12 +393,30 @@ input::placeholder { color: var(--text-disabled); }
 .connection-dot.on { background: var(--success); box-shadow: 0 0 6px var(--success); }
 .connection-dot.off { background: var(--error); }

+.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; }
-.ai-panel-header { padding: 12px 16px; border-bottom: 1px solid var(--border); font-weight: 700; font-size: 13px; color: var(--accent); }
+.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;
+  padding: 4px 10px; border-radius: var(--radius);
+  background: transparent; border: 1px solid var(--accent-dim);
+  color: var(--accent); font-size: 11px; font-weight: 600;
+  cursor: pointer; transition: all 0.15s;
+}
+.shell-analyze-btn:hover:not(:disabled) { background: var(--accent-bg); }
+.shell-analyze-btn:disabled { opacity: 0.4; cursor: not-allowed; }
+.shell-ai-token-bar { display: flex; align-items: center; gap: 8px; padding: 6px 12px; border-bottom: 1px solid var(--border); }
+.shell-ai-token-track { flex: 1; height: 3px; background: var(--bg-input); border-radius: 2px; overflow: hidden; }
+.shell-ai-token-fill { height: 100%; background: var(--accent); border-radius: 2px; transition: width 0.4s, background 0.3s; }
+.shell-ai-token-fill.warn { background: var(--warning); }
+.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.ai { background: var(--bg-card); border-left: 3px solid var(--accent); }
-.ai-message.user { background: var(--accent-bg); border-left: 3px solid var(--accent-muted); }
+.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); }
 .ai-message.thinking { background: var(--bg-elevated); border-left: 3px solid var(--info); font-style: italic; color: var(--text-tertiary); }
 .ai-message.tool { background: var(--bg-elevated); border-left: 3px solid var(--warning); }
 .ai-message.tool .tool-name { font-weight: 700; color: var(--warning); }
@@ -404,6 +424,46 @@ input::placeholder { color: var(--text-disabled); }
 .ai-panel-input { display: flex; gap: 6px; padding: 10px 12px; border-top: 1px solid var(--border); }
 .ai-panel-input input { flex: 1; font-size: 13px; padding: 6px 10px; }

+.shell-code-block {
+  background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius);
+  margin: 8px 0 4px; overflow: hidden;
+}
+.shell-code-block pre {
+  padding: 10px 12px; font-family: var(--font-mono); font-size: 12px; line-height: 1.5;
+  overflow-x: auto; color: var(--text-primary); margin: 0;
+}
+.shell-code-lang {
+  padding: 3px 10px; font-size: 10px; font-weight: 600; color: var(--text-tertiary);
+  background: var(--bg-surface); border-bottom: 1px solid var(--border);
+  text-transform: uppercase; letter-spacing: 0.5px;
+}
+.shell-code-actions {
+  display: flex; border-top: 1px solid var(--border); background: var(--bg-surface);
+}
+.shell-code-actions button {
+  flex: 1; display: flex; align-items: center; justify-content: center; gap: 4px;
+  padding: 5px 0; background: transparent; border: none; border-right: 1px solid var(--border);
+  color: var(--text-tertiary); font-size: 11px; cursor: pointer; transition: all 0.1s;
+  font-family: var(--font-sans);
+}
+.shell-code-actions button:last-child { border-right: none; }
+.shell-code-actions button:hover { background: var(--accent-bg); color: var(--accent); }
+
+.shell-analysis-modal {
+  background: var(--bg-elevated); border: 1px solid var(--border);
+  border-radius: var(--radius-lg); width: 720px; max-width: 90vw; max-height: 80vh;
+  display: flex; flex-direction: column; overflow: hidden;
+}
+.shell-analysis-modal-header {
+  display: flex; align-items: center; justify-content: space-between;
+  padding: 14px 20px; border-bottom: 1px solid var(--border);
+  font-weight: 700; font-size: 15px; color: var(--accent);
+}
+.shell-analysis-modal-body {
+  flex: 1; overflow-y: auto; padding: 20px; font-size: 14px; line-height: 1.5;
+  color: var(--text-primary); word-break: break-word;
+}
+
 .shell-modal-overlay {
  position: fixed; inset: 0; background: rgba(0,0,0,0.6);
  display: flex; align-items: center; justify-content: center; z-index: 1000;
@@ -480,6 +540,9 @@ input::placeholder { color: var(--text-disabled); }
 .provider-card-name { font-weight: 600; color: var(--text-primary); font-size: 14px; }
 .provider-card-actions { display: flex; gap: 8px; flex-shrink: 0; }
 .provider-card-meta { display: flex; gap: 16px; font-size: 12px; color: var(--text-tertiary); font-family: var(--font-mono); margin-top: 8px; }
+.provider-card-model { display: flex; align-items: center; justify-content: center; gap: 8px; margin-top: 12px; padding-top: 10px; border-top: 1px solid var(--border); }
+.provider-card-model-label { font-size: 11px; color: var(--text-tertiary); text-transform: uppercase; letter-spacing: 0.5px; }
+.provider-card-model-value { font-size: 14px; font-weight: 600; font-family: var(--font-mono); color: var(--accent); }
 .provider-card-form { margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border); }

 .provider-setup-hint {
@@ -504,10 +567,24 @@ input::placeholder { color: var(--text-disabled); }
 .config-update-name { color: var(--text-primary); font-weight: 600; font-size: 13px; min-width: 100px; }
 .config-update-versions { color: var(--text-tertiary); font-size: 12px; font-family: var(--font-mono); }

-.config-skill-row { display: flex; align-items: center; gap: 10px; padding: 8px 0; border-bottom: 1px solid var(--border); font-size: 13px; }
-.config-skill-row:last-child { border-bottom: none; }
-.config-skill-name { color: var(--text-primary); font-weight: 600; min-width: 120px; }
-.config-skill-desc { color: var(--text-tertiary); flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.skill-tiles { display: grid; grid-template-columns: repeat(auto-fill, minmax(200px, 1fr)); gap: 12px; }
+.skill-tile { background: var(--bg-card); border: 1px solid var(--border); border-radius: var(--radius); padding: 14px; cursor: pointer; transition: border-color 0.15s; }
+.skill-tile:hover { border-color: var(--accent-dim); }
+.skill-tile-name { font-weight: 600; color: var(--text-primary); font-size: 14px; margin-bottom: 6px; }
+.skill-tile-desc { font-size: 12px; color: var(--text-tertiary); overflow: hidden; text-overflow: ellipsis; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; }
+.skill-tile-tags { display: flex; gap: 6px; flex-wrap: wrap; margin-top: 10px; }
+.skill-detail-overlay { position: fixed; inset: 0; background: rgba(0,0,0,0.7); z-index: 50; display: flex; align-items: center; justify-content: center; }
+.skill-detail-panel { background: var(--bg-elevated); border: 1px solid var(--border); border-radius: var(--radius-lg); width: 90%; max-width: 600px; max-height: 80vh; display: flex; flex-direction: column; overflow: hidden; }
+.skill-detail-header { display: flex; align-items: center; justify-content: space-between; padding: 16px 20px; border-bottom: 1px solid var(--border); }
+.skill-detail-name { font-weight: 600; font-size: 16px; color: var(--text-primary); }
+.skill-detail-body { flex: 1; overflow-y: auto; padding: 20px; }
+.skill-detail-section { margin-bottom: 16px; }
+.skill-detail-label { font-size: 11px; font-weight: 700; color: var(--accent); text-transform: uppercase; letter-spacing: 0.5px; margin-bottom: 6px; }
+.skill-detail-meta { display: flex; gap: 8px; flex-wrap: wrap; }
+.skill-detail-content { font-family: var(--font-mono); font-size: 12px; color: var(--text-secondary); white-space: pre-wrap; background: var(--bg-card); border: 1px solid var(--border); border-radius: var(--radius); padding: 12px; line-height: 1.6; max-height: 300px; overflow-y: auto; }
+.skill-detail-deps { display: flex; flex-direction: column; gap: 6px; }
+.skill-detail-dep { font-size: 12px; color: var(--text-tertiary); display: flex; align-items: center; gap: 8px; }
+.skill-detail-dep .badge { font-size: 10px; }
 .chip-row { display: flex; gap: 8px; flex-wrap: wrap; }

 .config-toast {
@@ -539,6 +616,7 @@ input::placeholder { color: var(--text-disabled); }
 .dash-grid {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
+  grid-template-rows: repeat(2, 1fr);
  gap: 12px;
  padding: 16px;
  height: 100%;
@@ -548,7 +626,7 @@ input::placeholder { color: var(--text-disabled); }
  position: relative;
  background: var(--bg-card); border: 1px solid var(--border);
  border-radius: var(--radius-lg); padding: 14px 16px;
-  display: flex; flex-direction: column; gap: 8px;
+  display: flex; flex-direction: column; justify-content: center; gap: 8px;
  overflow: hidden;
 }

@@ -606,10 +684,10 @@ input::placeholder { color: var(--text-disabled); }
 }
 .dash-proc-name {
  font-size: 11px; font-weight: 600; color: var(--text-primary);
-  font-family: var(--font-mono);
+  font-family: var(--font-mono); flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
 }
 .dash-proc-res {
-  font-size: 10px; font-family: var(--font-mono); color: var(--text-tertiary);
+  font-size: 10px; font-family: var(--font-mono); color: var(--text-tertiary); flex-shrink: 0;
 }

 /* Commands */
@@ -629,6 +707,19 @@ input::placeholder { color: var(--text-disabled); }
  flex: 1; min-width: 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; }
 .dash-svc-row {
@@ -708,7 +799,17 @@ input::placeholder { color: var(--text-disabled); }

 /* ── Studio Feed ── */
 .studio-feed-layout { display: flex; flex-direction: column; height: 100%; overflow: hidden; }
-.studio-feed { flex: 1; overflow-y: auto; padding: 20px 24px; display: flex; flex-direction: column; gap: 4px; }
+.studio-feed-scroll-wrap { flex: 1; position: relative; overflow: hidden; }
+.studio-feed { height: 100%; overflow-y: auto; padding: 20px 24px; display: flex; flex-direction: column; gap: 4px; }
+.studio-scroll-btns { position: absolute; right: 16px; bottom: 16px; display: flex; flex-direction: column; gap: 4px; z-index: 10; }
+.studio-scroll-btn {
+  width: 32px; height: 32px; border-radius: 50%; padding: 0;
+  display: flex; align-items: center; justify-content: center;
+  background: var(--bg-card); border: 1px solid var(--border);
+  color: var(--text-tertiary); cursor: pointer; transition: all 0.15s;
+  opacity: 0.7;
+}
+.studio-scroll-btn:hover { background: var(--accent-bg); color: var(--accent); border-color: var(--accent-dim); opacity: 1; }
 .feed-loading { display: flex; align-items: center; justify-content: center; padding: 60px 0; }
 .feed-item { display: flex; gap: 10px; padding: 8px 12px; border-radius: var(--radius); animation: fadeIn 0.15s ease-out; }
 .feed-item:hover { background: var(--bg-card); }
@@ -730,7 +831,7 @@ input::placeholder { color: var(--text-disabled); }
 }
 .feed-role { font-size: 11px; font-weight: 700; color: var(--accent); text-transform: uppercase; letter-spacing: 0.5px; }
 .feed-time { font-size: 10px; color: var(--text-disabled); font-family: var(--font-mono); }
-.feed-content { font-size: 14px; line-height: 1.7; color: var(--text-primary); word-break: break-word; }
+.feed-content { font-size: 14px; line-height: 1.5; color: var(--text-primary); word-break: break-word; }
 .feed-system-badge { width: 6px; height: 6px; border-radius: 50%; background: var(--accent-dim); flex-shrink: 0; }
 .feed-system-text { font-size: 12px; color: var(--text-tertiary); font-style: italic; flex: 1; }
 .feed-system-text.compressed { color: var(--accent); font-style: normal; }
@@ -790,11 +891,11 @@ input::placeholder { color: var(--text-disabled); }
  background: var(--bg-surface); border-bottom: 1px solid var(--border); text-transform: uppercase; letter-spacing: 0.5px;
 }
 .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: 16px 0 8px; display: block; }
-.msg-h4 { font-size: 14px; font-weight: 700; color: var(--text-secondary); margin: 12px 0 6px; display: block; }
-.msg-bullet { display: block; padding-left: 16px; position: relative; margin: 2px 0; }
+.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; }
+.msg-bullet { display: block; padding-left: 16px; position: relative; margin: 1px 0; }
 .msg-bullet::before { content: '\2022'; position: absolute; left: 4px; color: var(--accent); }
-.msg-step { display: flex; gap: 8px; align-items: baseline; margin: 3px 0; }
+.msg-step { display: flex; gap: 8px; align-items: baseline; margin: 1px 0; }
 .msg-step-num { color: var(--accent); font-weight: 700; font-family: var(--font-mono); font-size: 13px; flex-shrink: 0; min-width: 20px; }
 .studio-cursor { display: inline-block; width: 8px; height: 16px; background: var(--accent); margin-left: 2px; vertical-align: text-bottom; animation: blink 0.8s step-end infinite; }
@keyframes blink { 50% { opacity: 0; } }
Author	SHA1	Message	Date
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
Augustin	1edd4f053a	fix(shell): improve tab reference stability and command queueing All checks were successful Beta Release / beta (push) Successful in 47s Details Add refs to track activeTab and pending commands outside render cycle. Flush queued commands after terminal initialization completes. Fix sendToTerminal to use stable refs instead of stale state. Enhance debug logging for tab operations. 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 16:10:54 +02:00
Augustin	92f943c3e6	fix(shell): add debug logging for tab tracking and WebSocket state All checks were successful Beta Release / beta (push) Successful in 46s Details Track which tab messages belong to via _tabId field to ensure AI responses are sent to the correct terminal tab. Add console.log in initTerminal, sendToTerminal for troubleshooting tab lifecycle issues. 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 15:53:13 +02:00
Augustin	1704b196cf	fix(terminal): refactor WebSocket cleanup, buffer management, and disposal All checks were successful Beta Release / beta (push) Successful in 52s Details - Add proper disposal tracking to prevent memory leaks - Move terminal buffer from localStorage to sessionStorage - Restore buffer immediately after first WS message - Fix clear detection logic and error handling - Add signal parameter support for abortable fetch requests 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 15:41:01 +02:00
Augustin	40ec493bae	fix(terminal): refactor WS cleanup, improve clear detection, fix sendToTerminal All checks were successful Beta Release / beta (push) Successful in 49s Details - Move defer cleanup after async goroutine setup to prevent premature closure - Remove unused Password field from terminal sessions struct - Fix line calculation in clear detection using viewportY instead of baseY - Add onStateChange callback to connectWebSocket for connection state - Add tabId parameter to sendToTerminal for targeted tab control - Simplify ShellAIMessage to use specific tab for command sending 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 15:20:48 +02:00
Augustin	233368c954	fix: restore buffer after WebSocket init, fix clear detection, fix streaming chunks All checks were successful Beta Release / beta (push) Successful in 50s Details - Delay buffer restoration by 300ms to avoid race condition with WebSocket init - Read current line from terminal buffer on Enter (reliable) instead of keystroke tracking - Fix streaming to emit full content instead of word-by-word chunks - Fix WebSocket readyState check in sendToTerminal - Extract and deduplicate AI message sending logic - Fix localStorage cleanup on tab close 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 14:15:14 +02:00
Augustin	00118f0803	refactor: remove locale panel, improve provider validation and terminal buffer persistence All checks were successful Beta Release / beta (push) Successful in 47s Details - Remove locale panel from config (language/keyboard already handled elsewhere) - Add per-provider key validation status with auto-check on load - Add missing tools section with AI-powered installation - Improve reset confirmation with modal - Persist terminal buffer to localStorage with auto-save - Detect clear command to wipe saved buffer - Remove AI tab concept (commands routed to active tab instead) - Remove renderTick hacks, use proper message keys 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 13:49:12 +02:00
Augustin	167ab82978	bump: v0.3.5 All checks were successful Beta Release / beta (push) Successful in 56s Details 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 13:16:08 +02:00
Augustin	a23c0c5b94	fix: display all quota models, center card content vertically Some checks failed Beta Release / beta (push) Has been cancelled Details - Handle all quota types in providersQuota, not just TIME_LIMIT - Extract model name from model field or type field - Use explicit limit value when available - Add vertical center alignment to quota card content 💘 Generated with Crush Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>	2026-04-24 13:15:51 +02:00
Augustin	24b31b0b47	fix: AI terminal init, Shift+Tab nav, code block rendering, command filtering All checks were successful Beta Release / beta (push) Successful in 45s Details - Fix AI terminal not initializing (wait for shell col visibility, remove offsetHeight guard) - Add Shift+Tab to cycle between shell terminals - Handle unclosed code blocks in renderContent (Shell + Studio) - Filter irrelevant commands from history (short/non-alpha backend + expanded frontend exclude list) 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 23:24:43 +02:00
Augustin	7ae4017672	fix(ci): replace jq with python3 in release step, add debug output All checks were successful Beta Release / beta (push) Successful in 40s Details 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 23:13:03 +02:00
Augustin	8c540eba93	feat: AI terminal, Z.AI quota, /model change, formatting fixes, update redirects All checks were successful Beta Release / beta (push) Successful in 49s Details - Add dedicated AI Terminal tab (non-deletable) shared between user and AI - Add Z.AI quota display on dashboard via /api/monitor/usage/quota/limit - Add /model change command in Studio to toggle MiniMax/ZAI - Apply Studio formatting (formatText, renderContent) to Shell AI messages - Add render tick refresh for Shell (1s streaming, 5s idle) - Add analysis viewer modal (Eye button) in Shell panel - Fix multi-shell tab creation with retry init and settings ref - Persist shell tabs to localStorage - Fix line spacing in Studio (line-height 1.7→1.5, cleanup stray <br/>) - Redirect Config updates to AI terminal via custom events - Fix CI: delete existing release before recreating - Bump version to 0.3.4 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 23:07:54 +02:00
Augustin	1074b019d3	feat(studio): Tab focuses textarea, autocomplete commands All checks were successful Beta Release / beta (push) Successful in 41s Details - Tab outside textarea focuses it - Tab inside textarea autocompletes / commands (/clear, /summarize, etc.) 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 22:13:02 +02:00
Augustin	2da0cf9421	fix(studio): convert newlines to <br/> in AI message rendering All checks were successful Beta Release / beta (push) Successful in 39s Details formatText now replaces \n with <br/> so AI responses display with proper line breaks instead of a single unbroken block. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 22:10:54 +02:00
Augustin	9987a586e2	fix(config): replace hardcoded model list with free text input All checks were successful Beta Release / beta (push) Successful in 41s Details Removed PROVIDER_MODELS hardcoded map. Model is now a simple text input pre-filled with the current model value. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 22:08:41 +02:00
Augustin	2827acfe96	feat(config): providers panel shows only MINIMAX/ZAI with model selector All checks were successful Beta Release / beta (push) Successful in 42s Details - Only MINIMAX and ZAI displayed (names in uppercase) - Each provider shows selectable model chips (MiniMax-M2.7, glm-4, etc.) - Save button always visible when editing, not just after validation - Removed setup hint text 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 22:06:21 +02:00
Augustin	afb6e77c7f	feat(dashboard): show top 5 most used commands as clickable chips All checks were successful Beta Release / beta (push) Successful in 43s Details Top commands (excluding ls/cd/pwd/clear/exit/history) displayed as large chips with usage count. Click to copy. Full history below. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 22:04:37 +02:00
Augustin	84be22661b	fix: tab containers height, dashboard 2-row grid, studio scroll buttons All checks were successful Beta Release / beta (push) Successful in 41s Details - .content > div now inherits full height so all tabs fill the viewport - Dashboard grid uses grid-template-rows: repeat(2, 1fr) for 6 equal tiles - Studio gets floating scroll-to-top / scroll-to-bottom buttons - Wrapped studio-feed in scroll-wrap for proper overflow 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 21:57:00 +02:00
Augustin	f9c4cf11ff	feat(shell): dedicated System Analyst AI, no code execution, analyze system All checks were successful Beta Release / beta (push) Successful in 45s Details - New ShellConvStore with persistent history (shell_conversation.json) - 100k token limit — input grays out, must /clear to continue - Commands limited to /clear and /help only - Shell AI has NO tools — read-only analysis, never executes code - "Analyste Système" panel with system analysis button - System analysis uses Studio AI to write system_analysis.md, prepended as context on every conversation start - Code blocks show "Copier" and "Terminal" buttons to copy or send code directly to the active terminal via WebSocket - Token bar shows usage with warning at 80% 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 21:50:06 +02:00
Augustin	eda7293286	fix: keep all tabs mounted, switch via CSS display instead of unmount All checks were successful Beta Release / beta (push) Successful in 42s Details All 4 tabs (Dashboard, Studio, Shell, Config) are now always mounted and toggled via .tab-hidden (display:none). This preserves: - Dashboard graph history across tab switches - Terminal session state and progress - Studio chat context - Config form state Dashboard polling pauses after 3 ticks when hidden to save resources and auto-resumes when the tab becomes visible again. 💘 Generated with Crush Assisted-by: GLM-5.1 via Crush <crush@charm.land>	2026-04-23 21:34:59 +02:00