fix(onboarding): require fields before advancing steps

- Validate each step before allowing goNext
- Show required error message on name step if empty
- Clear error on input change

💘 Generated with Crush

Assisted-by: MiniMax-M2.7 via Crush <crush@charm.land>

.gitea/workflows/ci-develop.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.24.3'
+          go-version: '1.24'
 
       - name: Setup Node
         uses: actions/setup-node@v4

.gitea/workflows/ci-main.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.24.3'
+          go-version: '1.24'
 
       - name: Setup Node
         uses: actions/setup-node@v4

.gitea/workflows/ci-pr.yml

@@ -13,7 +13,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.24.3'
+          go-version: '1.24'
 
       - name: Setup Node
         uses: actions/setup-node@v4

CHANGELOG.md

@@ -4,10 +4,98 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## v0.3.0
+
+### Changes since v0.2.1
+
+- fix(terminal): resolve PTY shell exec error, simplify CLI, unify Config tabs, restore Studio CSS (0b22109)
+- feat: add API key validation flow for AI provider config (7f67473)
+- feat(studio): replace sidebar layout with unified execution feed styles (040e482)
+- fix: guard against empty tabs array in closeTab (c8903ef)
+- refactor: redesign Config as settings window with sidebar panels, remove system overview from Dashboard (f3cb306)
+- feat: add multi-tab terminal with SSH support, config editing, and dashboard redesign (3cdcb22)
+- feat(studio): add i18n keys and CSS for redesigned AI chat interface (ee18bbe)
+- chore: bump version to 0.3.0 (b0b0e1d)
+- chore: remove dead code (packages, functions, types, constants) (fc79810)
+- docs: rewrite README and CHANGELOG for desktop app mode (f7222b0)
+- feat(web): add i18n support with FR/EN locales and keyboard layout awareness (11417d3)
+- refactor(web): redesign frontend for native web UX (3dc24ae)
+- refactor: remove TUI, desktop web UI is now the default and only mode (aa0ff19)
+- refactor: unify into single `muyue` binary with embedded desktop mode (3463605)
+- fix(ci): add frontend build step before Go vet/test/build (097cf40)
+- feat: add desktop app with React frontend, API backend, theme system (#2) (88d2a03)
+- chore: update CHANGELOG for v0.2.1 (1830c18)
+- feat: complete TUI redesign with cyberpunk theme (#1) (cb8e3d0)
+
+### Downloads
+
+| Platform | File |
+|----------|------|
+| Linux x86_64 | [muyue-linux-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.0/muyue-linux-amd64.tar.gz) |
+| Linux ARM64 | [muyue-linux-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.0/muyue-linux-arm64.tar.gz) |
+| macOS Intel | [muyue-darwin-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.0/muyue-darwin-amd64.tar.gz) |
+| macOS Apple Silicon | [muyue-darwin-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.0/muyue-darwin-arm64.tar.gz) |
+| Windows x86_64 | [muyue-windows-amd64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.0/muyue-windows-amd64.zip) |
+| Windows ARM64 | [muyue-windows-arm64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.0/muyue-windows-arm64.zip) |
+
+The binary includes both CLI and Desktop modes.
+Run `muyue` for TUI, `muyue desktop` for web UI.
+
+### Install
+
+**Linux (x86_64)**
+```bash
+curl -sL https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.0/muyue-linux-amd64.tar.gz | tar xz
+chmod +x muyue-linux-amd64
+sudo mv muyue-linux-amd64 /usr/local/bin/muyue
+```
+
+**macOS (Apple Silicon)**
+```bash
+curl -sL https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.0/muyue-darwin-arm64.tar.gz | tar xz
+chmod +x muyue-darwin-arm64
+sudo mv muyue-darwin-arm64 /usr/local/bin/muyue
+```
+
+**Windows (x86_64)**
+```powershell
+Invoke-WebRequest -Uri "https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.0/muyue-windows-amd64.zip" -OutFile "muyue.zip"
+Expand-Archive -Path "muyue.zip" -DestinationPath "."
+Move-Item muyue-windows-amd64.exe C:\Windows\muyue.exe
+```
+
+
 ## [Unreleased]
 
+### Security
+
+- **Command injection**: Removed non-functional AI sidebar from Shell.jsx that interpolated user input directly into a shell command (`echo "AI: ${text}"`). The panel was a stub with no real AI integration.
+- **WebSocket origin validation**: Terminal WebSocket handler now validates the `Origin` header matches the server's own host.
+- **DELETE method guard**: Terminal sessions DELETE endpoint now rejects non-DELETE methods.
+
+### Fixed
+
+- **Message ID collisions**: `generateMsgID()` now appends nanosecond suffix to prevent collisions under rapid creation.
+- **Legacy dir migration**: Config migration from `~/.muyue` to XDG path now logs errors instead of silently failing.
+- **MCP JSON parsing**: `json.Unmarshal` errors in MCP config loading are now handled instead of ignored.
+- **API header merging**: `client.js` `request()` now correctly merges caller headers with defaults (was overwriting `Content-Type`).
+- **Variable shadowing**: `t` translation function shadowed by `.filter(t => ...)` in Config.jsx and App.jsx — renamed to `tool`.
+
+### Changed
+
+- **Real SSE streaming**: Chat endpoint now streams AI responses via SSE (`data: {"content":"..."}` chunks) instead of fake 8-rune chunking. Frontend renders responses progressively as they arrive.
+- **Progressive rendering**: Studio.jsx now uses `StreamingItem` component to display partial AI output during streaming, with cursor animation.
+- **Theme from config**: App.jsx loads theme from user profile preferences on startup (was hardcoded to `cyberpunk-red`).
+- **Handlers split**: Monolithic `handlers.go` split into 6 focused files: `handlers_common.go`, `handlers_info.go`, `handlers_tools.go`, `handlers_config.go`, `handlers_chat.go`, `handlers_terminal.go`.
+- **Dynamic version**: Config `Version` field now uses `version.Version` constant instead of hardcoded `"0.1.0"`.
+- **Path construction**: `filepath.Join` used consistently in installer, MCP, scanner, and profiler for cross-platform safety.
+- **CI Go version**: All 3 CI workflows updated from `go-version: '1.24.3'` to `'1.24'` to match `go.mod`.
+- **Dead code removed**: Unused `addNotif` function in Dashboard.jsx, unused `layout` destructuring, dead `tools`/`updates`/`onRescan` props, dead AI sidebar in Shell.jsx, associated CSS and i18n keys.
+
 ### Added
 
+- **SendStream tests**: 3 new tests for the SSE streaming method (chunk parsing, history accumulation, API error handling) using `httptest` server.
+
 - **Desktop mode**: React 19 web UI served locally, auto-opens in browser. Frontend embedded in Go binary via `go:embed`.
 - **API backend**: 15 REST endpoints (`/api/info`, `/api/system`, `/api/tools`, `/api/config`, `/api/providers`, `/api/skills`, `/api/lsp`, `/api/mcp`, `/api/updates`, `/api/scan`, `/api/install`, `/api/terminal`, `/api/mcp/configure`, `/api/preferences`).
 - **i18n**: Full FR/EN translation system with keyboard layout awareness (AZERTY, QWERTY, QWERTZ). Preferences synced to backend.

cmd/muyue/main.go

@@ -3,103 +3,15 @@ package main
 import (
 	"fmt"
 	"os"
-	"os/exec"
 
 	"github.com/muyue/muyue/internal/config"
 	"github.com/muyue/muyue/internal/desktop"
-	"github.com/muyue/muyue/internal/installer"
-	"github.com/muyue/muyue/internal/lsp"
-	"github.com/muyue/muyue/internal/mcp"
-	"github.com/muyue/muyue/internal/orchestrator"
 	"github.com/muyue/muyue/internal/profiler"
-	"github.com/muyue/muyue/internal/scanner"
-	"github.com/muyue/muyue/internal/skills"
-	"github.com/muyue/muyue/internal/updater"
-	"github.com/muyue/muyue/internal/version"
 )
 
 func main() {
-	if len(os.Args) > 1 {
-		if isCommand(os.Args[1]) {
-			handleCommand(os.Args[1:])
-			return
-		}
-	}
-
-	runDesktop(os.Args[1:])
-}
-
-func isCommand(arg string) bool {
-	switch arg {
-	case "version", "-v", "--version",
-		"scan", "install", "update", "setup",
-		"config", "doctor", "lsp", "mcp", "skills",
-		"help", "-h", "--help":
-		return true
-	}
-	return false
-}
-
-func handleCommand(args []string) {
-	switch args[0] {
-	case "version", "-v", "--version":
-		fmt.Println(version.FullVersion())
-	case "scan":
-		runScan()
-	case "install":
-		runInstall(args[1:])
-	case "update":
-		runUpdate()
-	case "setup":
-		runSetup()
-	case "config":
-		showConfig()
-	case "doctor":
-		runDoctor()
-	case "lsp":
-		runLSP(args[1:])
-	case "mcp":
-		runMCP(args[1:])
-	case "skills":
-		runSkills(args[1:])
-	case "help", "-h", "--help":
-		printHelp()
-	}
-}
-
-func printHelp() {
-	fmt.Printf(`%s - AI-powered development environment assistant
-
-Usage:
-  muyue              Launch desktop app (opens browser)
-  muyue <command>    Run a specific command
-
-Options:
-  --port=PORT        Specify port (default: auto)
-  --no-open          Don't open browser automatically
-
-Commands:
-  version            Show version
-  scan               Scan your system for tools and runtimes
-  install [tools]    Install missing tools (needs sudo for some tools)
-  update             Check and apply updates for all tools
-  setup              Run first-time setup wizard
-  config             Show current configuration
-  doctor             Check that everything is properly configured
-  lsp [scan|install] Scan or install LSP servers
-  mcp [config|scan]  Configure MCP servers for Crush and Claude Code
-  skills [list|generate|deploy|init|delete] Manage AI coding skills
-  help               Show this help
-
-Note:
-  Some tools (docker, gh, etc.) require elevated privileges.
-  Run 'sudo muyue install' or use 'pkexec muyue install' if needed.
-`, version.FullVersion())
-}
-
-func runDesktop(args []string) {
 	cfg := loadOrSetupConfig()
-	if err := desktop.Run(cfg, args); err != nil {
+	if err := desktop.Run(cfg, os.Args[1:]); err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		os.Exit(1)
 	}
@@ -140,453 +52,3 @@ func loadOrSetupConfig() *config.MuyueConfig {
 
 	return cfg
 }
-
-func runScan() {
-	fmt.Println("Scanning system...")
-	result := scanner.ScanSystem()
-	fmt.Println(result.Summary())
-}
-
-func runInstall(tools []string) {
-	cfg := loadOrSetupConfig()
-	inst := installer.New(cfg)
-
-	if len(tools) == 0 {
-		result := scanner.ScanSystem()
-		var missing []string
-		for _, t := range result.Tools {
-			if !t.Installed {
-				missing = append(missing, t.Name)
-			}
-		}
-
-		if len(missing) == 0 {
-			fmt.Println("All tools are installed!")
-			return
-		}
-
-		fmt.Printf("Missing tools: %v\nInstalling...\n", missing)
-		tools = missing
-	}
-
-	if needsSudo(tools) && os.Geteuid() != 0 {
-		fmt.Println("Some tools require elevated privileges.")
-		if path, err := exec.LookPath("sudo"); err == nil {
-			fmt.Printf("Re-running with sudo...\n")
-			cmd := exec.Command(path, append([]string{os.Args[0], "install"}, tools...)...)
-			cmd.Stdin = os.Stdin
-			cmd.Stdout = os.Stdout
-			cmd.Stderr = os.Stderr
-			if err := cmd.Run(); err != nil {
-				fmt.Fprintf(os.Stderr, "sudo install failed: %v\n", err)
-				os.Exit(1)
-			}
-			config.Save(cfg)
-			return
-		}
-		if path, err := exec.LookPath("pkexec"); err == nil {
-			fmt.Printf("Re-running with pkexec...\n")
-			cmd := exec.Command(path, append([]string{os.Args[0], "install"}, tools...)...)
-			cmd.Stdin = os.Stdin
-			cmd.Stdout = os.Stdout
-			cmd.Stderr = os.Stderr
-			if err := cmd.Run(); err != nil {
-				fmt.Fprintf(os.Stderr, "pkexec install failed: %v\n", err)
-				os.Exit(1)
-			}
-			config.Save(cfg)
-			return
-		}
-		fmt.Println("Neither sudo nor pkexec found. Some installs may fail.")
-		fmt.Println("Try running: sudo muyue install")
-	}
-
-	results := inst.InstallAll(tools)
-	for _, r := range results {
-		status := "[OK]"
-		if !r.Success {
-			status = "[FAIL]"
-		}
-		fmt.Printf("  %s %s: %s\n", status, r.Tool, r.Message)
-	}
-
-	config.Save(cfg)
-}
-
-func needsSudo(tools []string) bool {
-	sudoTools := map[string]bool{
-		"docker": true, "git": true, "gh": true, "node": true, "python": true,
-	}
-	for _, t := range tools {
-		if sudoTools[t] {
-			return true
-		}
-	}
-	return false
-}
-
-func runUpdate() {
-	fmt.Println("Checking for updates...")
-	result := scanner.ScanSystem()
-	statuses := updater.CheckUpdates(result)
-
-	needsUpdate := false
-	for _, s := range statuses {
-		if s.NeedsUpdate {
-			fmt.Printf("  [!] %s: %s -> %s\n", s.Tool, s.Current, s.Latest)
-			needsUpdate = true
-		} else if s.Error == "" {
-			fmt.Printf("  [v] %s: up to date (%s)\n", s.Tool, s.Current)
-		} else {
-			fmt.Printf("  [?] %s: %s\n", s.Tool, s.Error)
-		}
-	}
-
-	if needsUpdate {
-		fmt.Println("\nApplying updates...")
-		results := updater.RunAutoUpdate(statuses)
-		for _, r := range results {
-			fmt.Printf("  %s: %s\n", r.Tool, r.Message)
-		}
-	}
-}
-
-func runSetup() {
-	cfg, err := profiler.RunFirstTimeSetup()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Setup error: %v\n", err)
-		os.Exit(1)
-	}
-
-	for i := range cfg.AI.Providers {
-		if cfg.AI.Providers[i].Active && cfg.AI.Providers[i].APIKey == "" {
-			key, err := profiler.AskAPIKey(cfg.AI.Providers[i].Name)
-			if err == nil && key != "" {
-				cfg.AI.Providers[i].APIKey = key
-			}
-		}
-	}
-
-	if err := config.Save(cfg); err != nil {
-		fmt.Fprintf(os.Stderr, "Save error: %v\n", err)
-		os.Exit(1)
-	}
-
-	fmt.Println("Setup complete!")
-}
-
-func showConfig() {
-	cfg, err := config.Load()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Config not found. Run `muyue setup` first.\n")
-		os.Exit(1)
-	}
-
-	fmt.Printf("Profile: %s (%s)\n", cfg.Profile.Name, cfg.Profile.Pseudo)
-	fmt.Printf("Email: %s\n", cfg.Profile.Email)
-	fmt.Printf("Editor: %s\n", cfg.Profile.Preferences.Editor)
-	fmt.Printf("Default AI: %s\n", cfg.Profile.Preferences.DefaultAI)
-	fmt.Printf("Languages: %v\n", cfg.Profile.Languages)
-
-	for _, p := range cfg.AI.Providers {
-		active := ""
-		if p.Active {
-			active = " (active)"
-		}
-		keyStatus := "no key"
-		if p.APIKey != "" {
-			keyStatus = "configured"
-		}
-		fmt.Printf("  %s: model=%s, key=%s%s\n", p.Name, p.Model, keyStatus, active)
-	}
-
-	fmt.Printf("BMAD: installed=%v, global=%v\n", cfg.BMAD.Installed, cfg.BMAD.Global)
-	fmt.Printf("Custom Prompt: %v\n", cfg.Terminal.CustomPrompt)
-}
-
-func runDoctor() {
-	ok := true
-	fmt.Println("Running diagnostics...")
-	fmt.Println()
-
-	fmt.Println("Configuration:")
-	if !config.Exists() {
-		fmt.Println("  [FAIL] Config file not found. Run 'muyue setup' first.")
-		ok = false
-	} else {
-		cfg, err := config.Load()
-		if err != nil {
-			fmt.Printf("  [FAIL] Config load error: %v\n", err)
-			ok = false
-		} else {
-			fmt.Println("  [OK]   Config file present")
-			hasKey := false
-			for _, p := range cfg.AI.Providers {
-				if p.Active && p.APIKey != "" {
-					hasKey = true
-				}
-			}
-			if hasKey {
-				fmt.Println("  [OK]   API key configured")
-			} else {
-				fmt.Println("  [FAIL] No API key set for active provider")
-				ok = false
-			}
-		}
-	}
-
-	fmt.Println("\nTools:")
-	result := scanner.ScanSystem()
-	installed := 0
-	for _, t := range result.Tools {
-		if t.Installed {
-			installed++
-			fmt.Printf("  [OK]   %s\n", t.Name)
-		} else {
-			fmt.Printf("  [FAIL] %s (not installed)\n", t.Name)
-		}
-	}
-	fmt.Printf("  Installed: %d/%d\n", installed, len(result.Tools))
-
-	fmt.Println("\nLSP Servers:")
-	servers := lsp.ScanServers()
-	lspOK := 0
-	for _, s := range servers {
-		if s.Installed {
-			lspOK++
-			fmt.Printf("  [OK]   %s (%s)\n", s.Name, s.Language)
-		}
-	}
-	fmt.Printf("  Available: %d/%d\n", lspOK, len(servers))
-
-	fmt.Println("\nMCP Servers:")
-	mcpServers := mcp.ScanServers()
-	mcpOK := 0
-	for _, s := range mcpServers {
-		if s.Installed {
-			mcpOK++
-		}
-	}
-	fmt.Printf("  Available: %d/%d\n", mcpOK, len(mcpServers))
-
-	fmt.Println("\nSkills:")
-	skillList, err := skills.List()
-	if err != nil || len(skillList) == 0 {
-		fmt.Println("  [FAIL] No skills. Run 'muyue skills init'.")
-		ok = false
-	} else {
-		fmt.Printf("  [OK]   %d skills installed\n", len(skillList))
-	}
-
-	fmt.Println()
-	if ok {
-		fmt.Println("All checks passed!")
-	} else {
-		fmt.Println("Some checks failed. Review the output above.")
-		os.Exit(1)
-	}
-}
-
-func runLSP(args []string) {
-	if len(args) == 0 {
-		args = []string{"scan"}
-	}
-
-	switch args[0] {
-	case "scan":
-		fmt.Println("Scanning LSP servers...")
-		servers := lsp.ScanServers()
-		installed := 0
-		for _, s := range servers {
-			if s.Installed {
-				installed++
-				fmt.Printf("  [v] %-35s (%s)\n", s.Name, s.Language)
-			} else {
-				fmt.Printf("  [ ] %-35s (%s)\n", s.Name, s.Language)
-			}
-		}
-		fmt.Printf("\nInstalled: %d/%d\n", installed, len(servers))
-	case "install":
-		if len(args) < 2 {
-			cfg := loadOrSetupConfig()
-			fmt.Printf("Installing LSP servers for: %v\n", cfg.Profile.Languages)
-			results := lsp.InstallForLanguages(cfg.Profile.Languages)
-			for _, r := range results {
-				if r.Installed {
-					fmt.Printf("  [OK] %s (%s)\n", r.Name, r.Language)
-				} else {
-					fmt.Printf("  [FAIL] %s (%s)\n", r.Name, r.Language)
-				}
-			}
-		} else {
-			for _, name := range args[1:] {
-				fmt.Printf("Installing %s...\n", name)
-				if err := lsp.InstallServer(name); err != nil {
-					fmt.Printf("  [FAIL] %s: %s\n", name, err)
-				} else {
-					fmt.Printf("  [OK] %s\n", name)
-				}
-			}
-		}
-	default:
-		fmt.Printf("Unknown lsp subcommand: %s (scan, install)\n", args[0])
-	}
-}
-
-func runMCP(args []string) {
-	if len(args) == 0 {
-		args = []string{"config"}
-	}
-
-	switch args[0] {
-	case "config":
-		cfg := loadOrSetupConfig()
-		fmt.Println("Configuring MCP servers for Crush and Claude Code...")
-		if err := mcp.ConfigureAll(cfg); err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			os.Exit(1)
-		}
-		fmt.Println("Done! MCP servers configured.")
-	case "scan":
-		fmt.Println("Scanning MCP servers...")
-		servers := mcp.ScanServers()
-		available := 0
-		for _, s := range servers {
-			if s.Installed {
-				available++
-				fmt.Printf("  [v] %-30s (%s)\n", s.Name, s.Category)
-			} else {
-				fmt.Printf("  [ ] %-30s (%s)\n", s.Name, s.Category)
-			}
-		}
-		fmt.Printf("\nAvailable: %d/%d\n", available, len(servers))
-	default:
-		fmt.Printf("Unknown mcp subcommand: %s (config, scan)\n", args[0])
-	}
-}
-
-func runSkills(args []string) {
-	if len(args) == 0 {
-		args = []string{"list"}
-	}
-
-	switch args[0] {
-	case "list", "ls":
-		skillsList, err := skills.List()
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			os.Exit(1)
-		}
-		if len(skillsList) == 0 {
-			fmt.Println("No skills found. Run `muyue skills init` to install built-in skills.")
-			return
-		}
-		fmt.Printf("Skills (%d):\n", len(skillsList))
-		for _, s := range skillsList {
-			target := s.Target
-			if target == "" {
-				target = "both"
-			}
-			fmt.Printf("  %-20s %-8s %s\n", s.Name, target, s.Description)
-		}
-
-	case "init":
-		fmt.Println("Installing built-in skills...")
-		if err := skills.InstallBuiltinSkills(); err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			os.Exit(1)
-		}
-		fmt.Println("Deploying to Crush and Claude Code...")
-		if err := skills.DeployAll(); err != nil {
-			fmt.Fprintf(os.Stderr, "Deploy error: %v\n", err)
-		}
-		fmt.Println("Done! Built-in skills installed and deployed.")
-
-	case "show":
-		if len(args) < 2 {
-			fmt.Println("Usage: muyue skills show <name>")
-			return
-		}
-		skill, err := skills.Get(args[1])
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			os.Exit(1)
-		}
-		fmt.Printf("Name:        %s\n", skill.Name)
-		fmt.Printf("Description: %s\n", skill.Description)
-		fmt.Printf("Author:      %s\n", skill.Author)
-		fmt.Printf("Version:     %s\n", skill.Version)
-		fmt.Printf("Target:      %s\n", skill.Target)
-		fmt.Printf("Tags:        %v\n", skill.Tags)
-		fmt.Printf("Path:        %s\n", skill.FilePath)
-		fmt.Printf("\n--- Content ---\n%s\n", skill.Content)
-
-	case "generate":
-		if len(args) < 3 {
-			fmt.Println("Usage: muyue skills generate <name> <description> [crush|claude|both]")
-			fmt.Println("Example: muyue skills generate docker-setup \"Set up Docker for a project\" both")
-			return
-		}
-		name := args[1]
-		description := args[2]
-		target := "both"
-		if len(args) > 3 {
-			target = args[3]
-		}
-
-		cfg := loadOrSetupConfig()
-		orch, err := orchestrator.New(cfg)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "AI not configured: %v\n", err)
-			os.Exit(1)
-		}
-
-		fmt.Printf("Generating skill '%s'...\n", name)
-		prompt := skills.BuildAIGeneratePrompt(name, description, target)
-		resp, err := orch.Send(prompt)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Generation error: %v\n", err)
-			os.Exit(1)
-		}
-
-		skill := &skills.Skill{
-			Name:        name,
-			Description: description,
-			Content:     resp,
-			Author:      "muyue-generated",
-			Version:     "0.1.0",
-			Target:      target,
-			Tags:        []string{"generated"},
-		}
-
-		if err := skills.Create(skill); err != nil {
-			fmt.Fprintf(os.Stderr, "Save error: %v\n", err)
-			os.Exit(1)
-		}
-
-		fmt.Printf("Skill '%s' created and deployed!\n", name)
-
-	case "deploy":
-		fmt.Println("Deploying all skills to Crush and Claude Code...")
-		if err := skills.DeployAll(); err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			os.Exit(1)
-		}
-		fmt.Println("Done!")
-
-	case "delete":
-		if len(args) < 2 {
-			fmt.Println("Usage: muyue skills delete <name>")
-			return
-		}
-		if err := skills.Delete(args[1]); err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			os.Exit(1)
-		}
-		fmt.Printf("Skill '%s' deleted.\n", args[1])
-
-	default:
-		fmt.Printf("Unknown skills subcommand: %s\n", args[0])
-		fmt.Println("Available: list, show, generate, deploy, init, delete")
-	}
-}

go.mod

@@ -1,6 +1,8 @@
 module github.com/muyue/muyue
 
-go 1.24.3
+go 1.24.2
+
+toolchain go1.24.3
 
 require (
 	github.com/charmbracelet/huh v1.0.0

internal/api/conversation.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"encoding/json"
+	"fmt"
 	"os"
 	"path/filepath"
 	"sync"
@@ -153,5 +154,5 @@ func (cs *ConversationStore) NeedsSummarization() bool {
 }
 
 func generateMsgID() string {
-	return time.Now().Format("20060102150405.000")
+	return time.Now().Format("20060102150405.000") + "-" + fmt.Sprintf("%d", time.Now().UnixNano())
 }

internal/api/handlers.go

@@ -1,531 +0,0 @@
-package api
-
-import (
-	"encoding/json"
-	"net/http"
-	"os/exec"
-
-	"github.com/muyue/muyue/internal/config"
-	"github.com/muyue/muyue/internal/lsp"
-	"github.com/muyue/muyue/internal/mcp"
-	"github.com/muyue/muyue/internal/orchestrator"
-	"github.com/muyue/muyue/internal/scanner"
-	"github.com/muyue/muyue/internal/skills"
-	"github.com/muyue/muyue/internal/updater"
-	"github.com/muyue/muyue/internal/version"
-)
-
-const summarizePrompt = `Résume la conversation suivante de manière concise et structurée. Garde les points clés, les décisions prises, le contexte technique important. Le résumé doit permettre de continuer la conversation sans perte de contexte. Réponds uniquement avec le résumé, sans meta-commentaire.`
-
-func writeJSON(w http.ResponseWriter, data interface{}) {
-	json.NewEncoder(w).Encode(data)
-}
-
-func writeError(w http.ResponseWriter, msg string, code int) {
-	w.WriteHeader(code)
-	json.NewEncoder(w).Encode(map[string]string{"error": msg})
-}
-
-func (s *Server) handleInfo(w http.ResponseWriter, r *http.Request) {
-	writeJSON(w, map[string]interface{}{
-		"name":    version.Name,
-		"version": version.Version,
-		"author":  version.Author,
-	})
-}
-
-func (s *Server) handleSystem(w http.ResponseWriter, r *http.Request) {
-	if s.scanResult == nil {
-		s.scanResult = scanner.ScanSystem()
-	}
-	writeJSON(w, map[string]interface{}{
-		"system": s.scanResult.System,
-	})
-}
-
-func (s *Server) handleTools(w http.ResponseWriter, r *http.Request) {
-	if s.scanResult == nil {
-		s.scanResult = scanner.ScanSystem()
-	}
-	type toolInfo struct {
-		Name      string `json:"name"`
-		Installed bool   `json:"installed"`
-		Version   string `json:"version"`
-		Path      string `json:"path"`
-	}
-	tools := make([]toolInfo, len(s.scanResult.Tools))
-	for i, t := range s.scanResult.Tools {
-		tools[i] = toolInfo{
-			Name:      t.Name,
-			Installed: t.Installed,
-			Version:   t.Version,
-			Path:      t.Path,
-		}
-	}
-	writeJSON(w, map[string]interface{}{
-		"tools": tools,
-		"total": len(tools),
-	})
-}
-
-func (s *Server) handleConfig(w http.ResponseWriter, r *http.Request) {
-	if s.config == nil {
-		writeError(w, "no config", http.StatusNotFound)
-		return
-	}
-	writeJSON(w, map[string]interface{}{
-		"profile":  s.config.Profile,
-		"terminal": s.config.Terminal,
-		"bmad":     s.config.BMAD,
-	})
-}
-
-func (s *Server) handleProviders(w http.ResponseWriter, r *http.Request) {
-	if s.config == nil {
-		writeError(w, "no config", http.StatusNotFound)
-		return
-	}
-	writeJSON(w, map[string]interface{}{
-		"providers": s.config.AI.Providers,
-	})
-}
-
-func (s *Server) handleSkills(w http.ResponseWriter, r *http.Request) {
-	list, err := skills.List()
-	if err != nil {
-		writeError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	writeJSON(w, map[string]interface{}{
-		"skills": list,
-		"count":  len(list),
-	})
-}
-
-func (s *Server) handleLSP(w http.ResponseWriter, r *http.Request) {
-	servers := lsp.ScanServers()
-	writeJSON(w, map[string]interface{}{
-		"servers": servers,
-	})
-}
-
-func (s *Server) handleMCP(w http.ResponseWriter, r *http.Request) {
-	servers := mcp.ScanServers()
-	writeJSON(w, map[string]interface{}{
-		"servers":    servers,
-		"configured": true,
-	})
-}
-
-func (s *Server) handleMCPConfigure(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "POST" {
-		writeError(w, "POST only", http.StatusMethodNotAllowed)
-		return
-	}
-	if err := mcp.ConfigureAll(s.config); err != nil {
-		writeError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	writeJSON(w, map[string]string{"status": "ok"})
-}
-
-func (s *Server) handleUpdates(w http.ResponseWriter, r *http.Request) {
-	result := scanner.ScanSystem()
-	statuses := updater.CheckUpdates(result)
-	type updateInfo struct {
-		Tool        string `json:"tool"`
-		Current     string `json:"current"`
-		Latest      string `json:"latest"`
-		NeedsUpdate bool   `json:"needsUpdate"`
-		Error       string `json:"error,omitempty"`
-	}
-	updates := make([]updateInfo, len(statuses))
-	for i, u := range statuses {
-		updates[i] = updateInfo{
-			Tool:        u.Tool,
-			Current:     u.Current,
-			Latest:      u.Latest,
-			NeedsUpdate: u.NeedsUpdate,
-			Error:       u.Error,
-		}
-	}
-	writeJSON(w, map[string]interface{}{
-		"updates": updates,
-	})
-}
-
-func (s *Server) handleInstall(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "POST" {
-		writeError(w, "POST only", http.StatusMethodNotAllowed)
-		return
-	}
-	var body struct {
-		Tools []string `json:"tools"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		writeError(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if len(body.Tools) == 0 {
-		writeError(w, "no tools specified", http.StatusBadRequest)
-		return
-	}
-	writeJSON(w, map[string]string{"status": "installing"})
-}
-
-func (s *Server) handleScan(w http.ResponseWriter, r *http.Request) {
-	s.scanResult = scanner.ScanSystem()
-	writeJSON(w, map[string]string{"status": "ok"})
-}
-
-func (s *Server) handleUpdatePreferences(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "PUT" {
-		writeError(w, "PUT only", http.StatusMethodNotAllowed)
-		return
-	}
-	if s.config == nil {
-		writeError(w, "no config", http.StatusNotFound)
-		return
-	}
-	var body struct {
-		Language       string `json:"language"`
-		KeyboardLayout string `json:"keyboard_layout"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		writeError(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if body.Language != "" {
-		s.config.Profile.Preferences.Language = body.Language
-	}
-	if body.KeyboardLayout != "" {
-		s.config.Profile.Preferences.KeyboardLayout = body.KeyboardLayout
-	}
-	if err := config.Save(s.config); err != nil {
-		writeError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	writeJSON(w, map[string]string{"status": "ok"})
-}
-
-func (s *Server) handleTerminal(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "POST" {
-		writeError(w, "POST only", http.StatusMethodNotAllowed)
-		return
-	}
-	var body struct {
-		Command string `json:"command"`
-		Cwd     string `json:"cwd"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		writeError(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if body.Command == "" {
-		writeError(w, "no command", http.StatusBadRequest)
-		return
-	}
-
-	shell := "/bin/sh"
-	if s, err := exec.LookPath("bash"); err == nil {
-		shell = s
-	}
-
-	cmd := exec.Command(shell, "-c", body.Command)
-	if body.Cwd != "" {
-		cmd.Dir = body.Cwd
-	}
-	out, err := cmd.CombinedOutput()
-
-	type termResult struct {
-		Output string `json:"output"`
-		Error  string `json:"error,omitempty"`
-	}
-	result := termResult{Output: string(out)}
-	if err != nil {
-		result.Error = err.Error()
-	}
-	writeJSON(w, result)
-}
-
-func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "POST" {
-		writeError(w, "POST only", http.StatusMethodNotAllowed)
-		return
-	}
-	var body struct {
-		Message string `json:"message"`
-		Stream  bool   `json:"stream"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		writeError(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if body.Message == "" {
-		writeError(w, "no message", http.StatusBadRequest)
-		return
-	}
-
-	s.convStore.Add("user", body.Message)
-
-	if s.convStore.NeedsSummarization() {
-		s.autoSummarize()
-	}
-
-	orb, err := orchestrator.New(s.config)
-	if err != nil {
-		writeError(w, err.Error(), http.StatusServiceUnavailable)
-		return
-	}
-	orb.SetSystemPrompt(`Tu es l'orchestrateur IA de Muyue Studio. Tu aides l'utilisateur dans ses tâches de développement logiciel. Tu peux :
-- Créer et gérer des plans de développement étape par étape
-- Proposer des agents (outils comme Crush, Claude Code, etc.) pour exécuter des tâches spécifiques
-- Suivre la progression de tâches multi-étapes
-- Suggérer des modifications de fichiers, des revues de code, et des décisions d'architecture
-
-Sois concis, actionnable, et structuré. Quand tu proposes un plan, utilise des étapes numérotées claires. Quand tu références des fichiers, utilise des chemins relatifs. Tu es intégré dans l'application desktop Muyue.`)
-
-	if body.Stream {
-		w.Header().Set("Content-Type", "text/event-stream")
-		w.Header().Set("Cache-Control", "no-cache")
-		w.Header().Set("Connection", "keep-alive")
-		w.Header().Set("Access-Control-Allow-Origin", "*")
-		w.WriteHeader(http.StatusOK)
-		flusher, canFlush := w.(http.Flusher)
-
-		result, err := orb.Send(body.Message)
-		if err != nil {
-			data, _ := json.Marshal(map[string]string{"error": err.Error()})
-			w.Write([]byte("data: " + string(data) + "\n\n"))
-			if canFlush {
-				flusher.Flush()
-			}
-			return
-		}
-
-		s.convStore.Add("assistant", result)
-
-		chunkSize := 8
-		runes := []rune(result)
-		for i := 0; i < len(runes); i += chunkSize {
-			end := i + chunkSize
-			if end > len(runes) {
-				end = len(runes)
-			}
-			chunk := string(runes[i:end])
-			data, _ := json.Marshal(map[string]string{"content": chunk})
-			w.Write([]byte("data: " + string(data) + "\n\n"))
-			if canFlush {
-				flusher.Flush()
-			}
-		}
-
-		data, _ := json.Marshal(map[string]string{"done": "true"})
-		w.Write([]byte("data: " + string(data) + "\n\n"))
-		if canFlush {
-			flusher.Flush()
-		}
-		return
-	}
-
-	result, err := orb.Send(body.Message)
-	if err != nil {
-		writeError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	s.convStore.Add("assistant", result)
-	writeJSON(w, map[string]string{"content": result})
-}
-
-func (s *Server) autoSummarize() {
-	messages := s.convStore.Get()
-	if len(messages) < 10 {
-		return
-	}
-
-	half := len(messages) / 2
-	var oldText string
-	for _, m := range messages[:half] {
-		oldText += m.Role + ": " + m.Content + "\n\n"
-	}
-
-	summary := s.convStore.GetSummary()
-	if summary != "" {
-		oldText = "Résumé précédent:\n" + summary + "\n\nNouveaux échanges:\n" + oldText
-	}
-
-	orb, err := orchestrator.New(s.config)
-	if err != nil {
-		return
-	}
-	orb.SetSystemPrompt(summarizePrompt)
-
-	result, err := orb.Send(oldText)
-	if err != nil {
-		return
-	}
-
-	s.convStore.SetSummary(result)
-	s.convStore.TrimOld(len(messages) - half)
-	s.convStore.Add("system", "[Conversation résumée automatiquement]")
-}
-
-func (s *Server) handleChatHistory(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "GET" {
-		writeError(w, "GET only", http.StatusMethodNotAllowed)
-		return
-	}
-	messages := s.convStore.Get()
-	writeJSON(w, map[string]interface{}{
-		"messages": messages,
-		"tokens":   s.convStore.ApproxTokenCount(),
-	})
-}
-
-func (s *Server) handleChatClear(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "POST" {
-		writeError(w, "POST only", http.StatusMethodNotAllowed)
-		return
-	}
-	s.convStore.Clear()
-	writeJSON(w, map[string]string{"status": "ok"})
-}
-
-func (s *Server) handleSaveProfile(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "PUT" {
-		writeError(w, "PUT only", http.StatusMethodNotAllowed)
-		return
-	}
-	if s.config == nil {
-		writeError(w, "no config", http.StatusNotFound)
-		return
-	}
-	var body struct {
-		Name     string `json:"name"`
-		Pseudo   string `json:"pseudo"`
-		Email    string `json:"email"`
-		Editor   string `json:"editor"`
-		Shell    string `json:"shell"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		writeError(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if body.Name != "" {
-		s.config.Profile.Name = body.Name
-	}
-	if body.Pseudo != "" {
-		s.config.Profile.Pseudo = body.Pseudo
-	}
-	if body.Email != "" {
-		s.config.Profile.Email = body.Email
-	}
-	if body.Editor != "" {
-		s.config.Profile.Preferences.Editor = body.Editor
-	}
-	if body.Shell != "" {
-		s.config.Profile.Preferences.Shell = body.Shell
-	}
-	if err := config.Save(s.config); err != nil {
-		writeError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	writeJSON(w, map[string]string{"status": "ok"})
-}
-
-func (s *Server) handleSaveProvider(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "PUT" {
-		writeError(w, "PUT only", http.StatusMethodNotAllowed)
-		return
-	}
-	if s.config == nil {
-		writeError(w, "no config", http.StatusNotFound)
-		return
-	}
-	var body struct {
-		Name    string `json:"name"`
-		APIKey  string `json:"api_key"`
-		Model   string `json:"model"`
-		BaseURL string `json:"base_url"`
-		Active  *bool  `json:"active"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		writeError(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if body.Name == "" {
-		writeError(w, "name required", http.StatusBadRequest)
-		return
-	}
-	found := false
-	for i := range s.config.AI.Providers {
-		if s.config.AI.Providers[i].Name == body.Name {
-			if body.APIKey != "" {
-				s.config.AI.Providers[i].APIKey = body.APIKey
-			}
-			if body.Model != "" {
-				s.config.AI.Providers[i].Model = body.Model
-			}
-			if body.BaseURL != "" {
-				s.config.AI.Providers[i].BaseURL = body.BaseURL
-			}
-			if body.Active != nil {
-				if *body.Active {
-					for j := range s.config.AI.Providers {
-						s.config.AI.Providers[j].Active = false
-					}
-				}
-				s.config.AI.Providers[i].Active = *body.Active
-			}
-			found = true
-			break
-		}
-	}
-	if !found {
-		writeError(w, "provider not found", http.StatusNotFound)
-		return
-	}
-	if err := config.Save(s.config); err != nil {
-		writeError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	writeJSON(w, map[string]string{"status": "ok"})
-}
-
-func (s *Server) handleRunUpdate(w http.ResponseWriter, r *http.Request) {
-	if r.Method != "POST" {
-		writeError(w, "POST only", http.StatusMethodNotAllowed)
-		return
-	}
-	var body struct {
-		Tool string `json:"tool"`
-	}
-	json.NewDecoder(r.Body).Decode(&body)
-
-	result := scanner.ScanSystem()
-	statuses := updater.CheckUpdates(result)
-
-	if body.Tool != "" {
-		for _, u := range statuses {
-			if u.Tool == body.Tool && u.NeedsUpdate {
-				updater.RunAutoUpdate([]updater.UpdateStatus{u})
-			}
-		}
-		writeJSON(w, map[string]string{"status": "ok", "tool": body.Tool})
-		return
-	}
-
-	needsUpdate := make([]updater.UpdateStatus, 0)
-	for _, u := range statuses {
-		if u.NeedsUpdate {
-			needsUpdate = append(needsUpdate, u)
-		}
-	}
-	if len(needsUpdate) > 0 {
-		updater.RunAutoUpdate(needsUpdate)
-	}
-	writeJSON(w, map[string]interface{}{
-		"status":  "ok",
-		"updated": len(needsUpdate),
-	})
-}

internal/api/handlers_chat.go

@@ -0,0 +1,236 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os/exec"
+	"regexp"
+	"strings"
+
+	"github.com/muyue/muyue/internal/orchestrator"
+)
+
+var toolCallRegex = regexp.MustCompile(`\[TOOL_CALL:\{[^\}]+\}\]`)
+
+func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	var body struct {
+		Message string `json:"message"`
+		Stream  bool   `json:"stream"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if body.Message == "" {
+		writeError(w, "no message", http.StatusBadRequest)
+		return
+	}
+
+	s.convStore.Add("user", body.Message)
+
+	if s.convStore.NeedsSummarization() {
+		s.autoSummarize()
+	}
+
+	orb, err := orchestrator.New(s.config)
+	if err != nil {
+		writeError(w, err.Error(), http.StatusServiceUnavailable)
+		return
+	}
+	orb.SetSystemPrompt(`Tu es l'assistant IA de Muyue Studio. Tu as accès à un outil "crush" pour exécuter des tâches complexes sur l'ordinateur de l'utilisateur.
+
+RÈGLES ABSOLUES:
+1. Tu as DEUX possibilités ONLY:
+   - Répondre directement à l'utilisateur avec tes connaissances
+   - Demander l'exécution d'une tâche via crush en utilisant ce format EXACT:
+     [TOOL_CALL:{"tool":"crush","task":"description de la tâche"}]
+
+2. Quand tu utilises [TOOL_CALL:...], le système exécutera la tâche et te donnera le résultat.
+   Tu peux ensuite répondre à l'utilisateur avec ce résultat.
+
+3. SOIS CONCIS - pas de blabla, vais droit au but.
+
+4. L'utilisateur ne voit PAS tes pensées entre <think> tags.
+
+5. EXEMPLES d'utilisation de tool:
+   - "cherche tous les fichiers .md dans le projet" → [TOOL_CALL:{"tool":"crush","task":"Recherche les fichiers .md dans le projet courant"}]
+   - "aide-moi à déboguer cette erreur" → tu peux répondre directement si tu as assez d'info, sinon utiliser tool
+   - "quelle est la météo?" → [TOOL_CALL:{"tool":"crush","task":"Cherche la météo actuelle"}]
+
+6. Ne fais PAS de multi-step tool calls dans une seule réponse. Attends le résultat avant de continuer.`)
+
+	if body.Stream {
+		w.Header().Set("Content-Type", "text/event-stream")
+		w.Header().Set("Cache-Control", "no-cache")
+		w.Header().Set("Connection", "keep-alive")
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.WriteHeader(http.StatusOK)
+		flusher, canFlush := w.(http.Flusher)
+
+		result, err := orb.SendStream(body.Message, func(chunk string) {
+			if strings.HasPrefix(chunk, "<think") {
+				data, _ := json.Marshal(map[string]string{"thinking": strings.TrimPrefix(chunk, "<think")})
+				w.Write([]byte("data: " + string(data) + "\n\n"))
+				if canFlush {
+					flusher.Flush()
+				}
+				return
+			}
+			if chunk == "</think>" {
+				data, _ := json.Marshal(map[string]string{"thinking_end": "true"})
+				w.Write([]byte("data: " + string(data) + "\n\n"))
+				if canFlush {
+					flusher.Flush()
+				}
+				return
+			}
+			data, _ := json.Marshal(map[string]string{"content": chunk})
+			w.Write([]byte("data: " + string(data) + "\n\n"))
+			if canFlush {
+				flusher.Flush()
+			}
+		})
+		if err != nil {
+			data, _ := json.Marshal(map[string]string{"error": err.Error()})
+			w.Write([]byte("data: " + string(data) + "\n\n"))
+			if canFlush {
+				flusher.Flush()
+			}
+			return
+		}
+
+		// Process tool calls if any
+		cleanResult := processToolCalls(result)
+		s.convStore.Add("assistant", cleanResult)
+
+		data, _ := json.Marshal(map[string]string{"done": "true"})
+		w.Write([]byte("data: " + string(data) + "\n\n"))
+		if canFlush {
+			flusher.Flush()
+		}
+		return
+	}
+
+	result, err := orb.Send(body.Message)
+	if err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	cleanResult := processToolCalls(result)
+	s.convStore.Add("assistant", cleanResult)
+	writeJSON(w, map[string]string{"content": cleanResult})
+}
+
+func processToolCalls(content string) string {
+	matches := toolCallRegex.FindAllString(content, -1)
+	if len(matches) == 0 {
+		return cleanThinkingTags(content)
+	}
+
+	var result strings.Builder
+	clean := content
+
+	for _, match := range matches {
+		// Extract tool and task from [TOOL_CALL:{...}]
+		inner := strings.TrimPrefix(match, "[TOOL_CALL:")
+		inner = strings.TrimSuffix(inner, "]}") + "}"
+
+		var call struct {
+			Tool string `json:"tool"`
+			Task string `json:"task"`
+		}
+		if err := json.Unmarshal([]byte(inner), &call); err != nil {
+			continue
+		}
+
+		if call.Tool == "crush" && call.Task != "" {
+			result.WriteString(fmt.Sprintf("> %s\n\n", call.Task))
+			output := executeCrush(call.Task)
+			result.WriteString(output)
+			result.WriteString("\n\n---\n\n")
+		}
+
+		clean = strings.Replace(clean, match, "", 1)
+	}
+
+	clean = cleanThinkingTags(clean)
+
+	if result.Len() > 0 {
+		clean = strings.TrimSpace(clean) + "\n\n" + strings.TrimSpace(result.String())
+	}
+
+	return clean
+}
+
+func cleanThinkingTags(content string) string {
+	re := regexp.MustCompile(`(?s)<think[^>]*>.*?</think>`)
+	return re.ReplaceAllString(content, "")
+}
+
+func executeCrush(task string) string {
+	cmd := exec.Command("crush", "run", task)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Sprintf("Erreur: %v\n%s", err, string(output))
+	}
+	return string(output)
+}
+
+func (s *Server) autoSummarize() {
+	messages := s.convStore.Get()
+	if len(messages) < 10 {
+		return
+	}
+
+	half := len(messages) / 2
+	var oldText string
+	for _, m := range messages[:half] {
+		oldText += m.Role + ": " + m.Content + "\n\n"
+	}
+
+	summary := s.convStore.GetSummary()
+	if summary != "" {
+		oldText = "Résumé précédent:\n" + summary + "\n\nNouveaux échanges:\n" + oldText
+	}
+
+	orb, err := orchestrator.New(s.config)
+	if err != nil {
+		return
+	}
+	orb.SetSystemPrompt(summarizePrompt)
+
+	result, err := orb.Send(oldText)
+	if err != nil {
+		return
+	}
+
+	s.convStore.SetSummary(result)
+	s.convStore.TrimOld(len(messages) - half)
+	s.convStore.Add("system", "[Conversation résumée automatiquement]")
+}
+
+func (s *Server) handleChatHistory(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		writeError(w, "GET only", http.StatusMethodNotAllowed)
+		return
+	}
+	messages := s.convStore.Get()
+	writeJSON(w, map[string]interface{}{
+		"messages": messages,
+		"tokens":   s.convStore.ApproxTokenCount(),
+	})
+}
+
+func (s *Server) handleChatClear(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	s.convStore.Clear()
+	writeJSON(w, map[string]string{"status": "ok"})
+}

internal/api/handlers_common.go

@@ -0,0 +1,17 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+const summarizePrompt = `Résume la conversation suivante de manière concise et structurée. Garde les points clés, les décisions prises, le contexte technique important. Le résumé doit permettre de continuer la conversation sans perte de contexte. Réponds uniquement avec le résumé, sans meta-commentaire.`
+
+func writeJSON(w http.ResponseWriter, data interface{}) {
+	json.NewEncoder(w).Encode(data)
+}
+
+func writeError(w http.ResponseWriter, msg string, code int) {
+	w.WriteHeader(code)
+	json.NewEncoder(w).Encode(map[string]string{"error": msg})
+}

internal/api/handlers_config.go

@@ -0,0 +1,486 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/muyue/muyue/internal/config"
+)
+
+func (s *Server) handleUpdatePreferences(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "PUT" {
+		writeError(w, "PUT only", http.StatusMethodNotAllowed)
+		return
+	}
+	if s.config == nil {
+		writeError(w, "no config", http.StatusNotFound)
+		return
+	}
+	var body struct {
+		Language       string `json:"language"`
+		KeyboardLayout string `json:"keyboard_layout"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if body.Language != "" {
+		s.config.Profile.Preferences.Language = body.Language
+	}
+	if body.KeyboardLayout != "" {
+		s.config.Profile.Preferences.KeyboardLayout = body.KeyboardLayout
+	}
+	if err := config.Save(s.config); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, map[string]string{"status": "ok"})
+}
+
+func (s *Server) handleSaveProfile(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "PUT" {
+		writeError(w, "PUT only", http.StatusMethodNotAllowed)
+		return
+	}
+	if s.config == nil {
+		writeError(w, "no config", http.StatusNotFound)
+		return
+	}
+	var body struct {
+		Name   string `json:"name"`
+		Pseudo string `json:"pseudo"`
+		Email  string `json:"email"`
+		Editor string `json:"editor"`
+		Shell  string `json:"shell"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if body.Name != "" {
+		s.config.Profile.Name = body.Name
+	}
+	if body.Pseudo != "" {
+		s.config.Profile.Pseudo = body.Pseudo
+	}
+	if body.Email != "" {
+		s.config.Profile.Email = body.Email
+	}
+	if body.Editor != "" {
+		s.config.Profile.Preferences.Editor = body.Editor
+	}
+	if body.Shell != "" {
+		s.config.Profile.Preferences.Shell = body.Shell
+	}
+	if err := config.Save(s.config); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, map[string]string{"status": "ok"})
+}
+
+func (s *Server) handleSaveProvider(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "PUT" {
+		writeError(w, "PUT only", http.StatusMethodNotAllowed)
+		return
+	}
+	if s.config == nil {
+		writeError(w, "no config", http.StatusNotFound)
+		return
+	}
+	var body struct {
+		Name    string `json:"name"`
+		APIKey  string `json:"api_key"`
+		Model   string `json:"model"`
+		BaseURL string `json:"base_url"`
+		Active  *bool  `json:"active"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if body.Name == "" {
+		writeError(w, "name required", http.StatusBadRequest)
+		return
+	}
+	found := false
+	for i := range s.config.AI.Providers {
+		if s.config.AI.Providers[i].Name == body.Name {
+			if body.APIKey != "" {
+				s.config.AI.Providers[i].APIKey = body.APIKey
+			}
+			if body.Model != "" {
+				s.config.AI.Providers[i].Model = body.Model
+			}
+			if body.BaseURL != "" {
+				s.config.AI.Providers[i].BaseURL = body.BaseURL
+			}
+			if body.Active != nil {
+				if *body.Active {
+					for j := range s.config.AI.Providers {
+						s.config.AI.Providers[j].Active = false
+					}
+				}
+				s.config.AI.Providers[i].Active = *body.Active
+			}
+			found = true
+			break
+		}
+	}
+	if !found {
+		writeError(w, "provider not found", http.StatusNotFound)
+		return
+	}
+	if err := config.Save(s.config); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, map[string]string{"status": "ok"})
+}
+
+func (s *Server) handleValidateProvider(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	var body struct {
+		Name    string `json:"name"`
+		APIKey  string `json:"api_key"`
+		Model   string `json:"model"`
+		BaseURL string `json:"base_url"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if body.APIKey == "" {
+		writeError(w, "api_key required", http.StatusBadRequest)
+		return
+	}
+
+	baseURL := body.BaseURL
+	if baseURL == "" {
+		for _, p := range s.config.AI.Providers {
+			if p.Name == body.Name {
+				baseURL = p.BaseURL
+				break
+			}
+		}
+	}
+	if baseURL == "" {
+		switch body.Name {
+		case "minimax":
+			baseURL = "https://api.minimax.io/v1"
+		case "openai":
+			baseURL = "https://api.openai.com/v1"
+		case "anthropic":
+			baseURL = "https://api.anthropic.com/v1"
+		default:
+			baseURL = "https://api.minimax.io/v1"
+		}
+	}
+
+	model := body.Model
+	if model == "" {
+		for _, p := range s.config.AI.Providers {
+			if p.Name == body.Name {
+				model = p.Model
+				break
+			}
+		}
+	}
+	if model == "" {
+		model = "MiniMax-M2.7"
+	}
+
+	reqBody, _ := json.Marshal(map[string]interface{}{
+		"model":      model,
+		"messages":   []map[string]string{{"role": "user", "content": "Hi"}},
+		"max_tokens": 5,
+		"stream":     false,
+	})
+
+	url := strings.TrimRight(baseURL, "/") + "/chat/completions"
+	req, err := http.NewRequest("POST", url, bytes.NewReader(reqBody))
+	if err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+body.APIKey)
+
+	client := &http.Client{Timeout: 15 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		writeError(w, "connection failed: "+err.Error(), http.StatusBadGateway)
+		return
+	}
+	defer resp.Body.Close()
+	respBody, _ := io.ReadAll(resp.Body)
+
+	if resp.StatusCode == http.StatusUnauthorized || resp.StatusCode == http.StatusForbidden {
+		writeError(w, "invalid_api_key", http.StatusUnauthorized)
+		return
+	}
+	if resp.StatusCode != http.StatusOK {
+		writeError(w, "api_error: "+string(respBody), http.StatusBadGateway)
+		return
+	}
+
+	writeJSON(w, map[string]interface{}{"status": "valid"})
+}
+
+func (s *Server) handleSaveTerminalSettings(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "PUT" {
+		writeError(w, "PUT only", http.StatusMethodNotAllowed)
+		return
+	}
+	if s.config == nil {
+		writeError(w, "no config", http.StatusNotFound)
+		return
+	}
+	var body struct {
+		FontSize   int    `json:"font_size"`
+		FontFamily string `json:"font_family"`
+		Theme      string `json:"theme"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if body.FontSize > 0 {
+		s.config.Terminal.FontSize = body.FontSize
+	}
+	if body.FontFamily != "" {
+		s.config.Terminal.FontFamily = body.FontFamily
+	}
+	if body.Theme != "" {
+		s.config.Terminal.Theme = body.Theme
+	}
+	if err := config.Save(s.config); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, map[string]interface{}{
+		"status": "ok",
+		"theme":  config.GetTerminalTheme(s.config.Terminal.Theme),
+	})
+}
+
+func (s *Server) handleGetTerminalThemes(w http.ResponseWriter, r *http.Request) {
+	themes := make([]map[string]string, 0, len(config.DEFAULT_TERMINAL_THEMES))
+	for id, theme := range config.DEFAULT_TERMINAL_THEMES {
+		themes = append(themes, map[string]string{
+			"id":   id,
+			"name": theme.Name,
+		})
+	}
+	writeJSON(w, map[string]interface{}{"themes": themes})
+}
+
+func (s *Server) handleResetConfig(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	dir, err := config.ConfigDir()
+	if err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	path := filepath.Join(dir, "config.yaml")
+	if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	s.config = config.Default()
+	if err := config.Save(s.config); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, map[string]string{"status": "ok"})
+}
+
+func (s *Server) handleApplyStarshipTheme(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	var body struct {
+		Theme string `json:"theme"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if body.Theme == "" {
+		body.Theme = s.config.Terminal.PromptTheme
+	}
+
+	cfgDir, err := config.ConfigDir()
+	if err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	starshipDir := filepath.Join(cfgDir, "starship")
+	if err := os.MkdirAll(starshipDir, 0755); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	themeFile := filepath.Join(starshipDir, "starship.toml")
+
+	themeContent := getStarshipThemeConfig(body.Theme)
+	if err := os.WriteFile(themeFile, []byte(themeContent), 0644); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	home, _ := os.UserHomeDir()
+	shellRCs := []string{
+		filepath.Join(home, ".bashrc"),
+		filepath.Join(home, ".zshrc"),
+	}
+	for _, rc := range shellRCs {
+		if _, err := os.Stat(rc); err != nil {
+			continue
+		}
+		content, _ := os.ReadFile(rc)
+		if strings.Contains(string(content), "STARSHIP_CONFIG") {
+			continue
+		}
+		exportLine := fmt.Sprintf("\n# Muyue Starship config\nexport STARSHIP_CONFIG=%s\n", themeFile)
+		f, err := os.OpenFile(rc, os.O_APPEND|os.O_WRONLY, 0644)
+		if err != nil {
+			continue
+		}
+		f.WriteString(exportLine)
+		f.Close()
+	}
+
+	s.config.Terminal.PromptTheme = body.Theme
+	config.Save(s.config)
+
+	writeJSON(w, map[string]interface{}{"status": "ok", "config": themeFile})
+}
+
+func getStarshipThemeConfig(theme string) string {
+	switch theme {
+	case "charm":
+		return `[format]
+before_format = "$"
+format = """
+$username$directory$git_branch$git_status$cmd_duration$line_break$character"""
+
+[character]
+success_symbol = "[➜](bold #00E676)"
+error_symbol = "[✗](bold #FF0033)"
+
+[directory]
+truncation_length = 3
+truncation_symbol = "…/"
+style = "bold #00BCD4"
+
+[username]
+show_on_left = false
+style_user = "bold #FF0033"
+style_root = "bold #FF0033"
+
+[git_branch]
+symbol = " "
+format = "on [$symbol$branch]($style)"
+style = "bold #FFD740"
+
+[git_status]
+format = "[$all_status$ahead_behind]($style) "
+style = "bold #FF1A5E"
+conflicted = "!"
+untracked = "?"
+modified = "~"
+staged = "[+]"
+renamed = "»"
+deleted = "-"
+
+[cmd_duration]
+min_time = 500
+format = "took [$duration]($style)"
+style = "bold #75715E"
+`
+	case "zerotwo":
+		return `[format]
+before_format = "$"
+format = """
+$username$directory$git_branch$git_status$cmd_duration$line_break$character"""
+
+[character]
+success_symbol = "[❯](bold #3B82F6)"
+error_symbol = "[❯](bold #EF4444)"
+
+[directory]
+truncation_length = 3
+truncation_symbol = "…/"
+style = "bold #8B5CF6"
+
+[username]
+show_on_left = false
+style_user = "bold #EC4899"
+style_root = "bold #EF4444"
+
+[git_branch]
+symbol = " "
+format = "on [$symbol$branch]($style)"
+style = "bold #F472B6"
+
+[git_status]
+format = "[$all_status$ahead_behind]($style) "
+style = "bold #EF4444"
+conflicted = "!"
+untracked = "?"
+modified = "~"
+staged = "[+]"
+renamed = "»"
+deleted = "-"
+
+[cmd_duration]
+min_time = 500
+format = "took [$duration]($style)"
+style = "bold #6B7280"
+`
+	default:
+		return `[format]
+before_format = "$"
+format = """
+$username$directory$git_branch$git_status$line_break$character"""
+
+[character]
+success_symbol = "[❯](bold green)"
+error_symbol = "[❯](bold red)"
+
+[directory]
+truncation_length = 3
+truncation_symbol = "…/"
+style = "bold cyan"
+
+[username]
+show_on_left = false
+style_user = "bold red"
+style_root = "bold red"
+
+[git_branch]
+symbol = " "
+format = "on [$symbol$branch]($style)"
+style = "bold yellow"
+
+[cmd_duration]
+min_time = 500
+format = "took [$duration]($style)"
+style = "bold bright-black"
+`
+	}
+}

internal/api/handlers_info.go

@@ -0,0 +1,119 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/muyue/muyue/internal/lsp"
+	"github.com/muyue/muyue/internal/mcp"
+	"github.com/muyue/muyue/internal/scanner"
+	"github.com/muyue/muyue/internal/skills"
+	"github.com/muyue/muyue/internal/version"
+)
+
+func (s *Server) handleInfo(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, map[string]interface{}{
+		"name":    version.Name,
+		"version": version.Version,
+		"author":  version.Author,
+	})
+}
+
+func (s *Server) handleSystem(w http.ResponseWriter, r *http.Request) {
+	if s.scanResult == nil {
+		s.scanResult = scanner.ScanSystem()
+	}
+	writeJSON(w, map[string]interface{}{
+		"system": s.scanResult.System,
+	})
+}
+
+func (s *Server) handleTools(w http.ResponseWriter, r *http.Request) {
+	if s.scanResult == nil {
+		s.scanResult = scanner.ScanSystem()
+	}
+	type toolInfo struct {
+		Name      string `json:"name"`
+		Installed bool   `json:"installed"`
+		Version   string `json:"version"`
+		Path      string `json:"path"`
+	}
+	tools := make([]toolInfo, len(s.scanResult.Tools))
+	for i, t := range s.scanResult.Tools {
+		tools[i] = toolInfo{
+			Name:      t.Name,
+			Installed: t.Installed,
+			Version:   t.Version,
+			Path:      t.Path,
+		}
+	}
+	writeJSON(w, map[string]interface{}{
+		"tools": tools,
+		"total": len(tools),
+	})
+}
+
+func (s *Server) handleConfig(w http.ResponseWriter, r *http.Request) {
+	if s.config == nil {
+		writeError(w, "no config", http.StatusNotFound)
+		return
+	}
+	writeJSON(w, map[string]interface{}{
+		"profile":  s.config.Profile,
+		"terminal": s.config.Terminal,
+		"bmad":     s.config.BMAD,
+	})
+}
+
+func (s *Server) handleProviders(w http.ResponseWriter, r *http.Request) {
+	if s.config == nil {
+		writeError(w, "no config", http.StatusNotFound)
+		return
+	}
+	writeJSON(w, map[string]interface{}{
+		"providers": s.config.AI.Providers,
+	})
+}
+
+func (s *Server) handleSkills(w http.ResponseWriter, r *http.Request) {
+	list, err := skills.List()
+	if err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, map[string]interface{}{
+		"skills": list,
+		"count":  len(list),
+	})
+}
+
+func (s *Server) handleLSP(w http.ResponseWriter, r *http.Request) {
+	servers := lsp.ScanServers()
+	writeJSON(w, map[string]interface{}{
+		"servers": servers,
+	})
+}
+
+func (s *Server) handleMCP(w http.ResponseWriter, r *http.Request) {
+	servers := mcp.ScanServers()
+	writeJSON(w, map[string]interface{}{
+		"servers":    servers,
+		"configured": true,
+	})
+}
+
+func (s *Server) handleMCPConfigure(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	if err := mcp.ConfigureAll(s.config); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, map[string]string{"status": "ok"})
+}
+
+func (s *Server) handleScan(w http.ResponseWriter, r *http.Request) {
+	s.scanResult = scanner.ScanSystem()
+	writeJSON(w, map[string]string{"status": "ok"})
+}

internal/api/handlers_terminal.go

@@ -0,0 +1,44 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"os/exec"
+)
+
+func (s *Server) handleTerminal(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	var body struct {
+		Command string `json:"command"`
+		Cwd     string `json:"cwd"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if body.Command == "" {
+		writeError(w, "no command", http.StatusBadRequest)
+		return
+	}
+
+	shell := detectShell()
+
+	cmd := exec.Command(shell, "-c", body.Command)
+	if body.Cwd != "" {
+		cmd.Dir = body.Cwd
+	}
+	out, err := cmd.CombinedOutput()
+
+	type termResult struct {
+		Output string `json:"output"`
+		Error  string `json:"error,omitempty"`
+	}
+	result := termResult{Output: string(out)}
+	if err != nil {
+		result.Error = err.Error()
+	}
+	writeJSON(w, result)
+}

internal/api/handlers_tools.go

@@ -0,0 +1,94 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/muyue/muyue/internal/scanner"
+	"github.com/muyue/muyue/internal/updater"
+)
+
+func (s *Server) handleUpdates(w http.ResponseWriter, r *http.Request) {
+	result := scanner.ScanSystem()
+	statuses := updater.CheckUpdates(result)
+	type updateInfo struct {
+		Tool        string `json:"tool"`
+		Current     string `json:"current"`
+		Latest      string `json:"latest"`
+		NeedsUpdate bool   `json:"needsUpdate"`
+		Error       string `json:"error,omitempty"`
+	}
+	updates := make([]updateInfo, len(statuses))
+	for i, u := range statuses {
+		updates[i] = updateInfo{
+			Tool:        u.Tool,
+			Current:     u.Current,
+			Latest:      u.Latest,
+			NeedsUpdate: u.NeedsUpdate,
+			Error:       u.Error,
+		}
+	}
+	writeJSON(w, map[string]interface{}{
+		"updates": updates,
+	})
+}
+
+func (s *Server) handleInstall(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	var body struct {
+		Tools []string `json:"tools"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if len(body.Tools) == 0 {
+		writeError(w, "no tools specified", http.StatusBadRequest)
+		return
+	}
+	writeJSON(w, map[string]string{"status": "installing"})
+}
+
+func (s *Server) handleRunUpdate(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	var body struct {
+		Tool string `json:"tool"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, "invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	result := scanner.ScanSystem()
+	statuses := updater.CheckUpdates(result)
+
+	if body.Tool != "" {
+		for _, u := range statuses {
+			if u.Tool == body.Tool && u.NeedsUpdate {
+				updater.RunAutoUpdate([]updater.UpdateStatus{u})
+			}
+		}
+		writeJSON(w, map[string]string{"status": "ok", "tool": body.Tool})
+		return
+	}
+
+	needsUpdate := make([]updater.UpdateStatus, 0)
+	for _, u := range statuses {
+		if u.NeedsUpdate {
+			needsUpdate = append(needsUpdate, u)
+		}
+	}
+	if len(needsUpdate) > 0 {
+		updater.RunAutoUpdate(needsUpdate)
+	}
+	writeJSON(w, map[string]interface{}{
+		"status":  "ok",
+		"updated": len(needsUpdate),
+	})
+}

internal/api/handlers_tools_exec.go

@@ -0,0 +1,80 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"os/exec"
+	"strings"
+)
+
+type toolCallRequest struct {
+	Tool string `json:"tool"`
+	Task string `json:"task"`
+}
+
+type toolResult struct {
+	Success bool   `json:"success"`
+	Output  string `json:"output"`
+	Error   string `json:"error,omitempty"`
+}
+
+func (s *Server) handleToolCall(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req toolCallRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	if req.Tool != "crush" {
+		writeError(w, "unsupported tool: "+req.Tool, http.StatusBadRequest)
+		return
+	}
+
+	if req.Task == "" {
+		writeError(w, "task is required", http.StatusBadRequest)
+		return
+	}
+
+	result := executeTool(req.Tool, req.Task)
+	writeJSON(w, result)
+}
+
+func executeTool(tool, task string) toolResult {
+	var cmd *exec.Cmd
+
+	switch tool {
+	case "crush":
+		cmd = exec.Command("crush", "run", task)
+	default:
+		return toolResult{Success: false, Error: "unknown tool: " + tool}
+	}
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return toolResult{
+			Success: false,
+			Output:  string(output),
+			Error:   err.Error(),
+		}
+	}
+
+	return toolResult{
+		Success: true,
+		Output:  string(output),
+	}
+}
+
+func buildToolMessage(tool, task string, history []string) string {
+	var b strings.Builder
+	b.WriteString("TASK: " + task + "\n\n")
+	b.WriteString("CONVERSATION HISTORY:\n")
+	for _, msg := range history {
+		b.WriteString(strings.Repeat(" ", 4) + strings.Join(strings.Split(msg, "\n"), "\n"+strings.Repeat(" ", 4)) + "\n")
+	}
+	return b.String()
+}

internal/api/server.go

@@ -43,9 +43,14 @@ func (s *Server) routes() {
 	s.mux.HandleFunc("/api/ws/terminal", s.handleTerminalWS)
 	s.mux.HandleFunc("/api/terminal/sessions", s.handleTerminalSessions)
 	s.mux.HandleFunc("/api/terminal/sessions/", s.handleTerminalSessionsDelete)
+	s.mux.HandleFunc("/api/terminal/themes", s.handleGetTerminalThemes)
+	s.mux.HandleFunc("/api/terminal/settings", s.handleSaveTerminalSettings)
 	s.mux.HandleFunc("/api/mcp/configure", s.handleMCPConfigure)
 	s.mux.HandleFunc("/api/config/profile", s.handleSaveProfile)
 	s.mux.HandleFunc("/api/config/provider", s.handleSaveProvider)
+	s.mux.HandleFunc("/api/config/reset", s.handleResetConfig)
+	s.mux.HandleFunc("/api/starship/apply-theme", s.handleApplyStarshipTheme)
+	s.mux.HandleFunc("/api/providers/validate", s.handleValidateProvider)
 	s.mux.HandleFunc("/api/update/run", s.handleRunUpdate)
 	s.mux.HandleFunc("/api/chat", s.handleChat)
 	s.mux.HandleFunc("/api/chat/history", s.handleChatHistory)

internal/api/terminal.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"runtime"
 	"strings"
 	"sync"
@@ -18,7 +19,23 @@ import (
 )
 
 var upgrader = websocket.Upgrader{
-	CheckOrigin: func(r *http.Request) bool { return true },
+	CheckOrigin: func(r *http.Request) bool {
+		origin := r.Header.Get("Origin")
+		if origin == "" {
+			return true
+		}
+		switch {
+		case strings.HasPrefix(origin, "http://127.0.0.1"),
+			strings.HasPrefix(origin, "http://localhost"),
+			strings.HasPrefix(origin, "http://[::1]"),
+			strings.HasPrefix(origin, "https://127.0.0.1"),
+			strings.HasPrefix(origin, "https://localhost"),
+			strings.HasPrefix(origin, "https://[::1]"):
+			return true
+		default:
+			return false
+		}
+	},
 }
 
 type wsMessage struct {
@@ -39,13 +56,17 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 	var initMsg wsMessage
 	_, raw, err := conn.ReadMessage()
 	if err != nil {
+		log.Printf("terminal: read init message failed: %v", err)
 		conn.WriteJSON(wsMessage{Type: "error", Data: "failed to read init message"})
 		return
 	}
+	log.Printf("terminal: init message received: %s", string(raw))
 	if err := json.Unmarshal(raw, &initMsg); err != nil {
+		log.Printf("terminal: unmarshal init message failed: %v", err)
 		conn.WriteJSON(wsMessage{Type: "error", Data: "invalid init message"})
 		return
 	}
+	log.Printf("terminal: init type=%q data=%q", initMsg.Type, initMsg.Data)
 
 	var cmd *exec.Cmd
 
@@ -79,28 +100,52 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 
 		cmd = exec.Command("ssh", sshArgs...)
 	} else {
-		shell := initMsg.Data
+		shell := strings.TrimSpace(initMsg.Data)
+		log.Printf("terminal: requested shell=%q, trimmed=%q", initMsg.Data, shell)
 		if shell == "" {
 			shell = detectShell()
+			log.Printf("terminal: auto-detected shell=%q", shell)
 		}
 
-		if strings.Contains(shell, "wsl") {
-			cmd = exec.Command("wsl", "--shell-type", "login")
-		} else if strings.Contains(shell, "powershell") || strings.Contains(shell, "pwsh") {
+		if shell == "" {
+			log.Printf("terminal: no shell detected, falling back to /bin/sh")
+			shell = "/bin/sh"
+		}
+
+		if path, err := exec.LookPath(shell); err == nil {
+			shell = path
+			log.Printf("terminal: resolved shell path=%q", shell)
+		}
+
+		if _, err := os.Stat(shell); err != nil {
+			log.Printf("terminal: shell stat failed: %v for %q", err, shell)
+			conn.WriteJSON(wsMessage{Type: "error", Data: fmt.Sprintf("shell not found: %s (resolved from: %q)", shell, initMsg.Data)})
+			return
+		}
+
+		shellName := filepath.Base(shell)
+		switch shellName {
+		case "wsl":
+			cmd = exec.Command(shell, "--shell-type", "login")
+		case "powershell", "pwsh":
 			cmd = exec.Command(shell, "-NoLogo", "-NoProfile")
-		} else {
+		case "fish":
 			cmd = exec.Command(shell, "--login")
+		default:
+			cmd = exec.Command(shell)
 		}
 	}
 
 	cmd.Env = append(os.Environ(), "TERM=xterm-256color")
 
+	log.Printf("terminal: starting pty with cmd=%q args=%v", cmd.Path, cmd.Args)
 	ptmx, err := pty.Start(cmd)
 	if err != nil {
-		log.Printf("pty start: %v", err)
+		log.Printf("terminal: pty start failed: %v", err)
 		conn.WriteJSON(wsMessage{Type: "error", Data: err.Error()})
 		return
 	}
+	log.Printf("terminal: pty started successfully")
 	defer func() {
 		ptmx.Close()
 		if cmd.Process != nil {
@@ -223,6 +268,10 @@ func (s *Server) handleTerminalSessions(w http.ResponseWriter, r *http.Request)
 }
 
 func (s *Server) handleTerminalSessionsDelete(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "DELETE" {
+		writeError(w, "DELETE only", http.StatusMethodNotAllowed)
+		return
+	}
 	name := strings.TrimPrefix(r.URL.Path, "/api/terminal/sessions/")
 	if name == "" {
 		writeError(w, "name required", http.StatusBadRequest)
@@ -250,8 +299,8 @@ func (s *Server) handleTerminalSessionsDelete(w http.ResponseWriter, r *http.Req
 func detectShell() string {
 	shells := []string{"zsh", "bash", "fish", "pwsh", "powershell"}
 	for _, s := range shells {
-		if _, err := exec.LookPath(s); err == nil {
-			return s
+		if path, err := exec.LookPath(s); err == nil {
+			return path
 		}
 	}
 	return "/bin/sh"

internal/config/config.go

@@ -2,10 +2,12 @@ package config
 
 import (
 	"fmt"
+	"log"
 	"os"
 	"path/filepath"
 
 	"github.com/muyue/muyue/internal/secret"
+	"github.com/muyue/muyue/internal/version"
 	"gopkg.in/yaml.v3"
 )
 
@@ -66,9 +68,73 @@ type MuyueConfig struct {
 		CustomPrompt bool            `yaml:"custom_prompt"`
 		PromptTheme  string          `yaml:"prompt_theme"`
 		SSH          []SSHConnection `yaml:"ssh"`
+		FontSize     int             `yaml:"font_size"`
+		FontFamily   string          `yaml:"font_family"`
+		Theme        string          `yaml:"theme"`
 	} `yaml:"terminal"`
 }
 
+type TerminalTheme struct {
+	Name      string `yaml:"name"`
+	Background string `yaml:"background"`
+	Foreground string `yaml:"foreground"`
+	Cursor    string `yaml:"cursor"`
+	Black     string `yaml:"black"`
+	Red       string `yaml:"red"`
+	Green     string `yaml:"green"`
+	Yellow    string `yaml:"yellow"`
+	Blue      string `yaml:"blue"`
+	Magenta   string `yaml:"magenta"`
+	Cyan      string `yaml:"cyan"`
+	White     string `yaml:"white"`
+}
+
+var DEFAULT_TERMINAL_THEMES = map[string]TerminalTheme{
+	"default": {
+		Name: "Default", Background: "#0A0A0C", Foreground: "#EAE0E2",
+		Cursor: "#FF0033", Black: "#0A0A0C", Red: "#FF0033",
+		Green: "#00E676", Yellow: "#FFD740", Blue: "#448AFF",
+		Magenta: "#FF1A5E", Cyan: "#00BCD4", White: "#EAE0E2",
+	},
+	"monokai": {
+		Name: "Monokai", Background: "#272822", Foreground: "#F8F8F2",
+		Cursor: "#F8F8F0", Black: "#272822", Red: "#F92672",
+		Green: "#A6E22E", Yellow: "#E6DB74", Blue: "#66D9EF",
+		Magenta: "#AE81FF", Cyan: "#A1EFE4", White: "#F8F8F2",
+	},
+	"gruvbox": {
+		Name: "Gruvbox", Background: "#282828", Foreground: "#EBDBB2",
+		Cursor: "#FB4934", Black: "#282828", Red: "#CC241D",
+		Green: "#98971A", Yellow: "#D79921", Blue: "#458588",
+		Magenta: "#B16286", Cyan: "#689D6A", White: "#EBDBB2",
+	},
+	"nord": {
+		Name: "Nord", Background: "#2E3440", Foreground: "#D8DEE9",
+		Cursor: "#D8DEE9", Black: "#2E3440", Red: "#BF616A",
+		Green: "#A3BE8C", Yellow: "#EBCB8B", Blue: "#81A1C1",
+		Magenta: "#B48EAD", Cyan: "#88C0D0", White: "#D8DEE9",
+	},
+	"solarized-dark": {
+		Name: "Solarized Dark", Background: "#002B36", Foreground: "#839496",
+		Cursor: "#D33682", Black: "#002B36", Red: "#DC322F",
+		Green: "#859900", Yellow: "#B58900", Blue: "#268BD2",
+		Magenta: "#D33682", Cyan: "#2AA198", White: "#FDF6E3",
+	},
+	"dracula": {
+		Name: "Dracula", Background: "#282A36", Foreground: "#F8F8F2",
+		Cursor: "#F8F8F2", Black: "#282A36", Red: "#FF5555",
+		Green: "#50FA7B", Yellow: "#F1FA8C", Blue: "#BD93F9",
+		Magenta: "#FF79C6", Cyan: "#8BE9FD", White: "#F8F8F2",
+	},
+}
+
+func GetTerminalTheme(name string) TerminalTheme {
+	if theme, ok := DEFAULT_TERMINAL_THEMES[name]; ok {
+		return theme
+	}
+	return DEFAULT_TERMINAL_THEMES["default"]
+}
+
 func ConfigDir() (string, error) {
 	configDir, err := os.UserConfigDir()
 	if err != nil {
@@ -79,7 +145,9 @@ func ConfigDir() (string, error) {
 	legacyDir := filepath.Join(homeDir(), ".muyue")
 	if _, err := os.Stat(legacyDir); err == nil {
 		if _, err := os.Stat(dir); err != nil {
-			os.Rename(legacyDir, dir)
+			if err := os.Rename(legacyDir, dir); err != nil {
+				log.Printf("config migration: rename %s to %s: %v", legacyDir, dir, err)
+			}
 		}
 	}
 
@@ -179,7 +247,7 @@ func Save(cfg *MuyueConfig) error {
 
 func Default() *MuyueConfig {
 	cfg := &MuyueConfig{
-		Version: "0.1.0",
+		Version: version.Version,
 		Profile: Profile{
 			Name:   "",
 			Pseudo: "muyue",

internal/config/config_test.go

@@ -4,12 +4,14 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/muyue/muyue/internal/version"
 )
 
 func TestDefault(t *testing.T) {
 	cfg := Default()
-	if cfg.Version != "0.1.0" {
-		t.Errorf("Expected version 0.1.0, got %s", cfg.Version)
+	if cfg.Version != version.Version {
+		t.Errorf("Expected version %s, got %s", version.Version, cfg.Version)
 	}
 	if cfg.Profile.Pseudo != "muyue" {
 		t.Errorf("Expected pseudo muyue, got %s", cfg.Profile.Pseudo)

internal/installer/installer.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"runtime"
 	"strings"
 
@@ -123,7 +124,7 @@ func (i *Installer) installBMAD() InstallResult {
 		return InstallResult{Tool: "bmad", Success: false, Message: err.Error()}
 	}
 
-	bmadDir := configDir + "/bmad"
+	bmadDir := filepath.Join(configDir, "bmad")
 	os.MkdirAll(bmadDir, 0755)
 
 	cmd := exec.Command("npx", "bmad-method@latest", "install",
@@ -175,7 +176,7 @@ func (i *Installer) installGo() InstallResult {
 	}
 
 	home, _ := os.UserHomeDir()
-	goDir := home + "/.local/go"
+	goDir := filepath.Join(home, ".local", "go")
 
 	cmd := exec.Command("bash", "-c", fmt.Sprintf(
 		"curl -sL https://go.dev/dl/go1.24.3.%s-%s.tar.gz | tar -C %s/.local -xzf -",
@@ -291,15 +292,15 @@ func (i *Installer) installGit() InstallResult {
 }
 
 
-func (i *Installer) getRCFile() string {
+	func (i *Installer) getRCFile() string {
 	home, _ := os.UserHomeDir()
 	switch i.system.Shell {
 	case "zsh":
-		return home + "/.zshrc"
+		return filepath.Join(home, ".zshrc")
 	case "fish":
-		return home + "/.config/fish/config.fish"
+		return filepath.Join(home, ".config", "fish", "config.fish")
 	default:
-		return home + "/.bashrc"
+		return filepath.Join(home, ".bashrc")
 	}
 }
 
@@ -340,7 +341,7 @@ func (i *Installer) installUv() InstallResult {
 			return InstallResult{Tool: "uv", Success: false, Message: fmt.Sprintf("install failed: %s: %s", err, string(output))}
 		}
 		rcFile := i.getRCFile()
-		appendLine(rcFile, "export PATH="+home+"/.local/bin:$PATH")
+		appendLine(rcFile, "export PATH="+filepath.Join(home, ".local", "bin")+":$PATH")
 		return InstallResult{Tool: "uv", Success: true, Message: "installed (added ~/.local/bin to PATH)"}
 	case platform.Windows:
 		cmd = exec.Command("powershell", "-Command", "irm https://astral.sh/uv/install.ps1 | iex")

internal/lsp/lsp.go

@@ -101,5 +101,3 @@ func InstallForLanguages(languages []string) []LSPServer {
 
 	return results
 }
-
-

internal/mcp/mcp.go

@@ -53,7 +53,7 @@ func ScanServers() []MCPServer {
 
 func getCoreEntries(homeDir string) []mcpEntry {
 	return []mcpEntry{
-		{"filesystem", "npx", []string{"-y", "@modelcontextprotocol/server-filesystem", homeDir + "/projects"}, nil},
+		{"filesystem", "npx", []string{"-y", "@modelcontextprotocol/server-filesystem", filepath.Join(homeDir, "projects")}, nil},
 		{"fetch", "npx", []string{"-y", "@modelcontextprotocol/server-fetch"}, nil},
 		{"memory", "npx", []string{"-y", "@modelcontextprotocol/server-memory"}, nil},
 	}
@@ -86,7 +86,9 @@ func writeMCPConfig(configPath string, mcpKey string, entries []mcpEntry) error
 	existing := map[string]interface{}{}
 	data, err := os.ReadFile(configPath)
 	if err == nil {
-		json.Unmarshal(data, &existing)
+		if err := json.Unmarshal(data, &existing); err != nil {
+			return fmt.Errorf("parse existing config: %w", err)
+		}
 	}
 
 	mcpMap := map[string]interface{}{}

internal/orchestrator/orchestrator.go

@@ -1,6 +1,7 @@
 package orchestrator
 
 import (
+	"bufio"
 	"bytes"
 	"encoding/json"
 	"fmt"
@@ -34,6 +35,9 @@ type ChatResponse struct {
 		Message struct {
 			Content string `json:"content"`
 		} `json:"message"`
+		Delta struct {
+			Content string `json:"content"`
+		} `json:"delta"`
 	} `json:"choices"`
 	Usage struct {
 		TotalTokens int `json:"total_tokens"`
@@ -161,6 +165,104 @@ func (o *Orchestrator) Send(userMessage string) (string, error) {
 	return content, nil
 }
 
+func (o *Orchestrator) SendStream(userMessage string, onChunk func(string)) (string, error) {
+	o.histMu.Lock()
+	o.history = append(o.history, Message{
+		Role:    "user",
+		Content: userMessage,
+	})
+
+	if len(o.history) > maxHistorySize {
+		o.history = o.history[len(o.history)-maxHistorySize:]
+	}
+
+	messages := make([]Message, 0, len(o.history)+1)
+	if o.systemPrompt != "" {
+		messages = append(messages, Message{Role: "system", Content: o.systemPrompt})
+	}
+	messages = append(messages, o.history...)
+
+	reqBody := ChatRequest{
+		Model:    o.provider.Model,
+		Messages: messages,
+		Stream:   true,
+	}
+	o.histMu.Unlock()
+
+	body, err := json.Marshal(reqBody)
+	if err != nil {
+		return "", fmt.Errorf("marshal request: %w", err)
+	}
+
+	baseURL := o.provider.BaseURL
+	if baseURL == "" {
+		baseURL = getProviderBaseURL(o.provider.Name)
+	}
+
+	url := strings.TrimRight(baseURL, "/") + "/chat/completions"
+
+	req, err := http.NewRequest("POST", url, bytes.NewReader(body))
+	if err != nil {
+		return "", fmt.Errorf("create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+o.provider.APIKey)
+
+	resp, err := o.client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("send request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		respBody, _ := io.ReadAll(resp.Body)
+		return "", fmt.Errorf("API error (%d): %s", resp.StatusCode, string(respBody))
+	}
+
+	var fullContent strings.Builder
+	scanner := bufio.NewScanner(resp.Body)
+	scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		if !strings.HasPrefix(line, "data: ") {
+			continue
+		}
+		data := strings.TrimPrefix(line, "data: ")
+		if data == "[DONE]" {
+			break
+		}
+
+		var chatResp ChatResponse
+		if err := json.Unmarshal([]byte(data), &chatResp); err != nil {
+			continue
+		}
+
+		if len(chatResp.Choices) > 0 {
+			chunk := chatResp.Choices[0].Delta.Content
+			if chunk != "" {
+				fullContent.WriteString(chunk)
+				onChunk(chunk)
+			}
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return fullContent.String(), fmt.Errorf("read stream: %w", err)
+	}
+
+	content := cleanAIResponse(fullContent.String())
+	o.histMu.Lock()
+	o.history = append(o.history, Message{
+		Role:    "assistant",
+		Content: content,
+	})
+	o.histMu.Unlock()
+
+	return content, nil
+}
+
 func cleanAIResponse(content string) string {
 	content = thinkRegex.ReplaceAllString(content, "")
 	lines := strings.Split(content, "\n")

internal/orchestrator/orchestrator_test.go

@@ -1,6 +1,9 @@
 package orchestrator
 
 import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
 	"strings"
 	"testing"
 
@@ -14,7 +17,7 @@ func TestCleanAIResponse(t *testing.T) {
 		expected string
 	}{
 		{
-			"removes standard think tags",
+			"malformed think tags pass through",
 			"<think internal reasoning</think Hello world",
 			"<think internal reasoning</think Hello world",
 		},
@@ -24,7 +27,7 @@ func TestCleanAIResponse(t *testing.T) {
 			"response",
 		},
 		{
-			"removes think with attrs",
+			"think with attrs, no closing bracket",
 			"<think type=re>reasoning</think result",
 			"<think type=re>reasoning</think result",
 		},
@@ -49,12 +52,12 @@ func TestCleanAIResponse(t *testing.T) {
 			"",
 		},
 		{
-			"removes valid think block",
+			"malformed think block no closing bracket",
 			"<think some reasoning here</think rest",
 			"<think some reasoning here</think rest",
 		},
 		{
-			"removes simple think",
+			"malformed simple think no closing bracket",
 			"before<think reasoning</think after",
 			"before<think reasoning</think after",
 		},
@@ -146,3 +149,128 @@ func TestNewNoAPIKey(t *testing.T) {
 		t.Error("Should fail with no API key")
 	}
 }
+
+func TestSendStreamChunks(t *testing.T) {
+	sseBody := `data: {"choices":[{"delta":{"content":"Hello"}}]}
+data: {"choices":[{"delta":{"content":" world"}}]}
+data: {"choices":[{"delta":{"content":"!"}}]}
+data: [DONE]
+`
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Header.Get("Authorization") != "Bearer test-key" {
+			http.Error(w, "unauthorized", http.StatusUnauthorized)
+			return
+		}
+		var reqBody ChatRequest
+		if err := json.NewDecoder(r.Body).Decode(&reqBody); err != nil {
+			http.Error(w, "bad request", http.StatusBadRequest)
+			return
+		}
+		if !reqBody.Stream {
+			http.Error(w, "stream must be true", http.StatusBadRequest)
+			return
+		}
+		w.Header().Set("Content-Type", "text/event-stream")
+		w.Write([]byte(sseBody))
+	}))
+	defer ts.Close()
+
+	cfg := config.Default()
+	cfg.AI.Providers[0].Active = true
+	cfg.AI.Providers[0].APIKey = "test-key"
+	cfg.AI.Providers[0].BaseURL = ts.URL
+
+	orb, err := New(cfg)
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+
+	var chunks []string
+	result, err := orb.SendStream("hi", func(chunk string) {
+		chunks = append(chunks, chunk)
+	})
+	if err != nil {
+		t.Fatalf("SendStream: %v", err)
+	}
+	if result != "Hello world!" {
+		t.Errorf("SendStream result = %q, want %q", result, "Hello world!")
+	}
+	if len(chunks) != 3 {
+		t.Fatalf("expected 3 chunks, got %d: %v", len(chunks), chunks)
+	}
+	if strings.Join(chunks, "") != "Hello world!" {
+		t.Errorf("chunks joined = %q, want %q", strings.Join(chunks, ""), "Hello world!")
+	}
+}
+
+func TestSendStreamHistory(t *testing.T) {
+	callCount := 0
+	sseBody := `data: {"choices":[{"delta":{"content":"reply"}}]}
+data: [DONE]
+`
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		callCount++
+		var reqBody ChatRequest
+		if err := json.NewDecoder(r.Body).Decode(&reqBody); err != nil {
+			http.Error(w, "bad request", http.StatusBadRequest)
+			return
+		}
+		if callCount == 1 {
+			if len(reqBody.Messages) != 2 {
+				t.Errorf("first call: expected 2 messages (system + 1 user), got %d", len(reqBody.Messages))
+			}
+		} else {
+			if len(reqBody.Messages) != 4 {
+				t.Errorf("second call: expected 4 messages (system + 3 history), got %d", len(reqBody.Messages))
+			}
+		}
+		w.Header().Set("Content-Type", "text/event-stream")
+		w.Write([]byte(sseBody))
+	}))
+	defer ts.Close()
+
+	cfg := config.Default()
+	cfg.AI.Providers[0].Active = true
+	cfg.AI.Providers[0].APIKey = "test-key"
+	cfg.AI.Providers[0].BaseURL = ts.URL
+
+	orb, err := New(cfg)
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	orb.SetSystemPrompt("you are helpful")
+
+	_, _ = orb.SendStream("first", func(string) {})
+	_, _ = orb.SendStream("second", func(string) {})
+
+	orb.histMu.Lock()
+	if len(orb.history) != 4 {
+		t.Errorf("expected 4 history entries (2 user + 2 assistant), got %d", len(orb.history))
+	}
+	orb.histMu.Unlock()
+}
+
+func TestSendStreamAPIError(t *testing.T) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, `{"error":"rate limited"}`, http.StatusTooManyRequests)
+	}))
+	defer ts.Close()
+
+	cfg := config.Default()
+	cfg.AI.Providers[0].Active = true
+	cfg.AI.Providers[0].APIKey = "test-key"
+	cfg.AI.Providers[0].BaseURL = ts.URL
+
+	orb, err := New(cfg)
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+
+	_, err = orb.SendStream("hi", func(string) {})
+	if err == nil {
+		t.Error("expected error for non-200 response")
+	}
+	if !strings.Contains(err.Error(), "429") {
+		t.Errorf("error should mention status code, got: %v", err)
+	}
+}

internal/platform/platform_test.go

@@ -1,6 +1,7 @@
 package platform
 
 import (
+	"strings"
 	"testing"
 )
 
@@ -43,16 +44,9 @@ func TestString(t *testing.T) {
 	if s == "" {
 		t.Error("String should not be empty")
 	}
-	if !contains(s, "linux") {
+	if !strings.Contains(s, "linux") {
 		t.Error("Should contain OS")
 	}
 }
 
-func contains(s, sub string) bool {
-	for i := 0; i+len(sub) <= len(s); i++ {
-		if s[i:i+len(sub)] == sub {
-			return true
-		}
-	}
-	return false
-}
+

internal/profiler/profiler.go

@@ -279,7 +279,7 @@ func AskAPIKey(providerName string) (string, error) {
 
 	field := huh.NewInput().
 		Title(fmt.Sprintf("Enter your %s API key:", providerName)).
-		Description("The key will be stored locally in ~/.muyue/config.yaml").
+		Description("The key will be stored locally in ~/.config/muyue/config.yaml").
 		EchoMode(huh.EchoModePassword).
 		Value(&apiKey)
 

internal/scanner/scanner.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"regexp"
 	"strings"
 	"sync"
@@ -169,7 +170,7 @@ func checkShellSetup() bool {
 	home, _ := os.UserHomeDir()
 	rcFiles := []string{".bashrc", ".zshrc", ".config/fish/config.fish"}
 	for _, f := range rcFiles {
-		data, err := os.ReadFile(home + "/" + f)
+		data, err := os.ReadFile(filepath.Join(home, f))
 		if err != nil {
 			continue
 		}

internal/version/version.go

@@ -2,7 +2,7 @@ package version
 
 const (
 	Name    = "muyue"
-	Version = "0.3.0"
+	Version = "0.3.2"
 	Author  = "La Légion de Muyue"
 )
 

web/src/api/client.js

@@ -2,8 +2,8 @@ const API_BASE = '/api'
 
 async function request(path, options = {}) {
   const res = await fetch(`${API_BASE}${path}`, {
-    headers: { 'Content-Type': 'application/json' },
     ...options,
+    headers: { 'Content-Type': 'application/json', ...(options.headers || {}) },
   })
   if (!res.ok) {
     const err = await res.json().catch(() => ({ error: res.statusText }))
@@ -28,14 +28,19 @@ const api = {
   savePreferences: (prefs) => request('/preferences', { method: 'PUT', body: JSON.stringify(prefs) }),
   saveProfile: (profile) => request('/config/profile', { method: 'PUT', body: JSON.stringify(profile) }),
   saveProvider: (provider) => request('/config/provider', { method: 'PUT', body: JSON.stringify(provider) }),
+  resetConfig: () => request('/config/reset', { method: 'POST' }),
+  applyStarshipTheme: (theme) => request('/starship/apply-theme', { method: 'POST', body: JSON.stringify({ theme }) }),
+  validateProvider: (provider) => request('/providers/validate', { method: 'POST', body: JSON.stringify(provider) }),
   runUpdate: (tool) => request('/update/run', { method: 'POST', body: JSON.stringify({ tool: tool || '' }) }),
   runCommand: (command, cwd) => request('/terminal', { method: 'POST', body: JSON.stringify({ command, cwd }) }),
   getTerminalSessions: () => request('/terminal/sessions'),
   addSSHConnection: (conn) => request('/terminal/sessions', { method: 'POST', body: JSON.stringify(conn) }),
   deleteSSHConnection: (name) => request(`/terminal/sessions/${encodeURIComponent(name)}`, { method: 'DELETE' }),
+  getTerminalThemes: () => request('/terminal/themes'),
+  saveTerminalSettings: (settings) => request('/terminal/settings', { method: 'PUT', body: JSON.stringify(settings) }),
   getChatHistory: () => request('/chat/history'),
   clearChat: () => request('/chat/clear', { method: 'POST' }),
-  sendChat: (message, stream = true) => {
+  sendChat: (message, stream = true, onChunk) => {
     if (!stream) {
       return request('/chat', { method: 'POST', body: JSON.stringify({ message, stream: false }) })
     }
@@ -63,7 +68,12 @@ const api = {
               const data = JSON.parse(line.slice(6))
               if (data.error) { reject(new Error(data.error)); return }
               if (data.done) { resolve(full); return }
-              if (data.content) full += data.content
+              if (data.content) {
+                full += data.content
+                if (onChunk) onChunk(full, data)
+              } else if (data.thinking !== undefined || data.thinking_end) {
+                if (onChunk) onChunk(full, data)
+              }
             } catch {}
           }
         }

web/src/components/App.jsx

@@ -7,6 +7,7 @@ import Dashboard from './Dashboard'
 import Studio from './Studio'
 import Shell from './Shell'
 import Config from './Config'
+import OnboardingWizard from './OnboardingWizard'
 
 export default function App() {
   const [activeTab, setActiveTab] = useState('dash')
@@ -14,6 +15,8 @@ export default function App() {
   const [clock, setClock] = useState(new Date())
   const [updates, setUpdates] = useState([])
   const [tools, setTools] = useState([])
+  const [config, setConfig] = useState(null)
+  const [showOnboarding, setShowOnboarding] = useState(false)
   const { t, layout } = useI18n()
 
   const TABS = useMemo(() => [
@@ -27,7 +30,16 @@ export default function App() {
     api.getInfo().then(setInfo).catch(() => {})
     api.getTools().then(d => setTools(d.tools || [])).catch(() => {})
     api.getUpdates().then(d => setUpdates(d.updates || [])).catch(() => {})
-    applyTheme(getTheme('cyberpunk-red'))
+    api.getConfig().then(d => {
+      setConfig(d)
+      const theme = d.profile?.preferences?.theme || 'cyberpunk-red'
+      applyTheme(getTheme(theme))
+      const hasProfile = d.profile?.name || d.profile?.pseudo
+      if (!hasProfile) setShowOnboarding(true)
+    }).catch(() => {
+      applyTheme(getTheme('cyberpunk-red'))
+      setShowOnboarding(true)
+    })
   }, [])
 
   useEffect(() => {
@@ -57,7 +69,7 @@ export default function App() {
   const switchTab = useCallback((tabId) => setActiveTab(tabId), [])
 
   const hasUpdates = updates.some(u => u.needsUpdate)
-  const installed = tools.filter(t => t.installed).length
+  const installed = tools.filter(tool => tool.installed).length
 
   const WINDOW_SHORTCUTS = useMemo(() => ({
     dash: [
@@ -80,10 +92,10 @@ export default function App() {
 
   const renderContent = () => {
     switch (activeTab) {
-      case 'dash': return <Dashboard tools={tools} updates={updates} api={api} onRescan={t => setTools(t)} />
+      case 'dash': return <Dashboard api={api} />
       case 'studio': return <Studio api={api} />
       case 'shell': return <Shell api={api} />
-      case 'config': return <Config api={api} onThemeChange={() => {}} />
+      case 'config': return <Config api={api} />
       default: return null
     }
   }
@@ -143,6 +155,8 @@ export default function App() {
           </span>
         </div>
       </footer>
+
+      {showOnboarding && <OnboardingWizard api={api} onComplete={() => setShowOnboarding(false)} />}
     </div>
   )
 }

web/src/components/Config.jsx

@@ -1,5 +1,5 @@
 import { useState, useEffect, useCallback } from 'react'
-import { User, Brain, RefreshCw, Globe, Wrench } from 'lucide-react'
+import { User, Brain, RefreshCw, Globe, Wrench, Monitor } from 'lucide-react'
 import { useI18n, LANGUAGES } from '../i18n'
 import { getLayoutList } from '../i18n/keyboards'
 
@@ -9,6 +9,7 @@ const PANELS = [
   { id: 'updates', icon: RefreshCw },
   { id: 'locale', icon: Globe },
   { id: 'skills', icon: Wrench },
+  { id: 'system', icon: Monitor },
 ]
 
 export default function Config({ api }) {
@@ -24,9 +25,10 @@ export default function Config({ api }) {
   const [editProfile, setEditProfile] = useState(false)
   const [editProvider, setEditProvider] = useState(null)
   const [profileForm, setProfileForm] = useState({})
-  const [providerForm, setProviderForm] = useState({})
+  const [providerForm, setProviderForm] = useState({}) // keyed by provider name
   const [toast, setToast] = useState(null)
 
+
   const layouts = getLayoutList()
 
   const loadData = useCallback(() => {
@@ -39,11 +41,13 @@ export default function Config({ api }) {
         editor: d.profile?.preferences?.editor || '',
         shell: d.profile?.preferences?.shell || '',
       })
+
     }).catch(() => {})
     api.getProviders().then(d => setProviders(d.providers || [])).catch(() => {})
     api.getSkills().then(d => setSkillList(d.skills || [])).catch(() => {})
     api.getUpdates().then(d => setUpdates(d.updates || [])).catch(() => {})
     api.getTools().then(d => setTools(d.tools || [])).catch(() => {})
+
   }, [api])
 
   useEffect(() => { loadData() }, [loadData])
@@ -103,9 +107,11 @@ export default function Config({ api }) {
     }
   }
 
-  const handleSaveProvider = async () => {
+  const handleSaveProvider = async (name) => {
+    const form = providerForm[name]
+    if (!form) return
     try {
-      await api.saveProvider(providerForm)
+      await api.saveProvider({ name, ...form })
       setEditProvider(null)
       loadData()
       showToast(t('config.saved'))
@@ -115,44 +121,43 @@ export default function Config({ api }) {
   }
 
   const openProviderEdit = (p) => {
-    setProviderForm({
-      name: p.name,
-      api_key: p.apiKey || '',
-      model: p.model || '',
-      base_url: p.baseURL || '',
-    })
+    setProviderForm(prev => ({
+      ...prev,
+      [p.name]: {
+        name: p.name,
+        api_key: p.apiKey || '',
+        model: p.model || '',
+        base_url: p.baseURL || '',
+      },
+    }))
     setEditProvider(p.name)
   }
 
   const needsUpdateCount = updates.filter(u => u.needsUpdate).length
-  const installedCount = tools.filter(t => t.installed).length
-  const missingCount = tools.filter(t => !t.installed).length
+  const installedCount = tools.filter(tool => tool.installed).length
+  const missingCount = tools.filter(tool => !tool.installed).length
 
   return (
     <div className="config-window">
       {toast && <div className="config-toast">{toast}</div>}
 
-      <div className="config-sidebar">
+      <div className="config-tabs-bar">
         {PANELS.map(p => {
           const Icon = p.icon
           return (
             <div
               key={p.id}
-              className={`config-sidebar-item ${activePanel === p.id ? 'active' : ''}`}
+              className={`nav-tab ${activePanel === p.id ? 'active' : ''}`}
               onClick={() => setActivePanel(p.id)}
             >
-              <Icon size={16} />
-              <span>{t(`config.panels.${p.id}`)}</span>
+              <span className="tab-icon"><Icon size={15} /></span>
+              {t(`config.panels.${p.id}`)}
             </div>
           )
         })}
       </div>
 
       <div className="config-panel-area">
-        <div className="config-panel-header">
-          <h2 className="config-panel-title">{t(`config.panels.${activePanel}`)}</h2>
-        </div>
-
         <div className="config-panel-body">
           {activePanel === 'profile' && (
             <PanelProfile
@@ -193,6 +198,10 @@ export default function Config({ api }) {
           {activePanel === 'skills' && (
             <PanelSkills skillList={skillList} t={t} />
           )}
+          {activePanel === 'system' && (
+            <PanelSystem api={api} t={t} />
+          )}
+
         </div>
       </div>
     </div>
@@ -252,48 +261,82 @@ function PanelProfile({ config, editProfile, profileForm, setProfileForm, setEdi
 }
 
 function PanelProviders({ providers, editProvider, providerForm, setProviderForm, setEditProvider, openProviderEdit, handleSaveProvider, api, loadData, t }) {
+  const [validating, setValidating] = useState(null)
+  const [validationStatus, setValidationStatus] = useState(null)
+
+  const handleValidate = async (name, apiKey, model, baseUrl) => {
+    setValidating(name)
+    setValidationStatus(null)
+    try {
+      await api.validateProvider({ name, api_key: apiKey, model, base_url: baseUrl })
+      setValidationStatus({ provider: name, valid: 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}` })
+      }
+    }
+    setValidating(null)
+  }
+
   return (
     <div className="config-providers-list">
-      {providers.map((p, i) => (
-        <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>
-              {p.active && <span className="badge accent">{t('config.active')}</span>}
-            </div>
-            <div className="provider-card-actions">
-              {editProvider !== p.name && (
-                <button className="ghost sm" onClick={() => openProviderEdit(p)}>{t('config.editProvider')}</button>
-              )}
-              {!p.active && editProvider !== p.name && (
-                <button className="sm" onClick={async () => {
-                  await api.saveProvider({ name: p.name, active: true })
-                  loadData()
-                }}>{t('config.activate')}</button>
-              )}
-            </div>
-          </div>
-
-          {editProvider !== p.name ? (
-            <div className="provider-card-meta">
-              <span className="mono">{p.model || '—'}</span>
-              <span style={{ color: p.apiKey ? 'var(--success)' : 'var(--error)' }}>
-                {p.apiKey ? t('config.keyConfigured') : t('config.noKey')}
-              </span>
-            </div>
-          ) : (
-            <div className="provider-card-form">
-              <FormInput label={t('config.apiKey')} value={providerForm.api_key} onChange={v => setProviderForm(f => ({ ...f, api_key: v }))} type="password" />
-              <FormInput label={t('config.model')} value={providerForm.model} onChange={v => setProviderForm(f => ({ ...f, model: v }))} />
-              <FormInput label={t('config.baseUrl')} value={providerForm.base_url} onChange={v => setProviderForm(f => ({ ...f, base_url: v }))} />
-              <div className="config-card-actions">
-                <button className="primary sm" onClick={handleSaveProvider}>{t('config.save')}</button>
-                <button className="ghost sm" onClick={() => setEditProvider(null)}>{t('config.cancel')}</button>
+      <div className="provider-setup-hint">{t('config.setupDescription')}</div>
+      {providers.map((p, i) => {
+        const isEditing = editProvider === p.name
+        const isValidationTarget = validationStatus?.provider === 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>
+                {p.apiKey && <span className="badge ok">{t('config.keyConfigured')}</span>}
+                {!p.apiKey && <span className="badge error">{t('config.noKey')}</span>}
+                {isValidationTarget && validationStatus?.valid && <span className="badge ok">{t('config.keyValid')}</span>}
+                {isValidationTarget && !validationStatus?.valid && <span className="badge error">{validationStatus?.error}</span>}
               </div>
             </div>
-          )}
-        </div>
-      ))}
+
+            <div className="provider-card-form">
+              <div className="provider-setup-token-row">
+                <div className="provider-setup-token-input">
+                  <label className="config-form-label">{t('config.apiKey')}</label>
+                  <input
+                    className="config-form-input"
+                    type="password"
+                    placeholder={t('config.tokenPlaceholder')}
+                    value={isEditing ? (providerForm[p.name]?.api_key || '') : ''}
+                    onChange={e => {
+                      if (!isEditing) openProviderEdit(p)
+                      setProviderForm(prev => ({
+                        ...prev,
+                        [p.name]: { ...(prev[p.name] || {}), api_key: e.target.value },
+                      }))
+                    }}
+                  />
+                </div>
+                <div className="provider-setup-token-actions">
+                  <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)}
+                  >
+                    {validating === p.name ? t('config.validating') : t('config.validateKey')}
+                  </button>
+                  {isValidationTarget && validationStatus?.valid && (
+                    <button className="sm" onClick={() => handleSaveProvider(p.name)}>{t('config.save')}</button>
+                  )}
+                </div>
+              </div>
+              <div className="provider-card-meta" style={{ marginTop: 8 }}>
+                <span className="mono">{p.model || '—'}</span>
+              </div>
+            </div>
+          </div>
+        )
+      })}
     </div>
   )
 }
@@ -412,6 +455,73 @@ function PanelSkills({ skillList, t }) {
   )
 }
 
+function PanelSystem({ api, t }) {
+  const [resetConfirm, setResetConfirm] = useState(false)
+  const [toast, setToast] = useState(null)
+
+  const showToast = (msg) => {
+    setToast(msg)
+    setTimeout(() => setToast(null), 3000)
+  }
+
+  const handleReset = async () => {
+    try {
+      await api.resetConfig()
+      setResetConfirm(false)
+      showToast(t('config.resetDone'))
+      setTimeout(() => window.location.reload(), 1500)
+    } catch (err) {
+      showToast(`${t('config.error')}: ${err.message}`)
+    }
+  }
+
+  const handleApplyStarship = async () => {
+    try {
+      await api.applyStarshipTheme('charm')
+      showToast(t('config.starshipApplied'))
+    } catch (err) {
+      showToast(`${t('config.error')}: ${err.message}`)
+    }
+  }
+
+  return (
+    <>
+      {toast && <div className="config-toast">{toast}</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>
+        <button className="sm primary" onClick={handleApplyStarship}>
+          {t('config.applyStarship')}
+        </button>
+      </div>
+      <div className="config-card" style={{ marginTop: 12 }}>
+        <div className="config-card-row" style={{ marginBottom: 16 }}>
+          <span className="config-card-label" style={{ fontWeight: 600 }}>{t('config.resetConfig')}</span>
+        </div>
+        {resetConfirm ? (
+          <div>
+            <div style={{ fontSize: 12, color: 'var(--warning)', marginBottom: 12 }}>
+              {t('config.resetConfirm')}
+            </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>
+          </div>
+        ) : (
+          <button className="sm ghost danger" onClick={() => setResetConfirm(true)}>
+            {t('config.resetConfig')}
+          </button>
+        )}
+      </div>
+    </>
+  )
+}
+
 function FormInput({ label, value, onChange, type = 'text' }) {
   return (
     <div className="config-form-field">

web/src/components/Dashboard.jsx

@@ -1,14 +1,10 @@
 import { useState } from 'react'
 import { useI18n } from '../i18n'
 
-export default function Dashboard({ api, onRescan }) {
-  const { t, layout } = useI18n()
+export default function Dashboard({ api }) {
+  const { t } = useI18n()
   const [notifications, setNotifications] = useState([])
 
-  const addNotif = (text, type) => {
-    setNotifications(prev => [{ text, type, id: Date.now(), time: new Date() }, ...prev])
-  }
-
   return (
     <div className="dashboard-layout">
       <div className="dashboard-content">
@@ -47,7 +43,7 @@ export default function Dashboard({ api, onRescan }) {
                 {notifications.map(n => (
                   <div key={n.id} className={`notif-row notif-${n.type}`}>
                     <span className="notif-time">
-                      {n.time.toLocaleTimeString(layout.locale, { hour: '2-digit', minute: '2-digit', second: '2-digit' })}
+                      {n.time.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit', second: '2-digit' })}
                     </span>
                     <span className="notif-text">{n.text}</span>
                   </div>

web/src/components/OnboardingWizard.jsx

@@ -0,0 +1,288 @@
+import { useState, useEffect } from 'react'
+import { Sparkles, ArrowRight, ArrowLeft } from 'lucide-react'
+import { useI18n, LANGUAGES } from '../i18n'
+import { getLayoutList } from '../i18n/keyboards'
+
+const STEPS = [
+  { key: 'welcome', title: 'welcome', field: null },
+  { key: 'name', title: 'name', field: 'name' },
+  { key: 'language', title: 'language', field: 'language' },
+  { key: 'keyboard', title: 'keyboard', field: 'keyboard' },
+  { key: 'editor', title: 'editor', field: 'editor' },
+  { key: 'done', title: 'done', field: null },
+]
+
+const EDITOR_SUGGESTIONS = ['vim', 'nvim', 'vscode', 'emacs', 'nano', 'helix']
+
+export default function OnboardingWizard({ api, onComplete }) {
+  const { t, language, keyboard, setLanguage, setKeyboard } = useI18n()
+  const [step, setStep] = useState(0)
+  const [answers, setAnswers] = useState({
+    name: '',
+    language: 'fr',
+    keyboard: 'azerty',
+    editor: '',
+  })
+  const [saving, setSaving] = useState(false)
+  const [error, setError] = useState(null)
+  const [requiredError, setRequiredError] = useState(false)
+
+  const current = STEPS[step]
+  const layouts = getLayoutList()
+
+  const goNext = () => {
+    if (step < STEPS.length - 1) {
+      if (!canProceed) { setRequiredError(true); return }
+      setRequiredError(false)
+      setStep(step + 1)
+    }
+  }
+
+  const canProceed = (() => {
+    switch (current.key) {
+      case 'welcome': return true
+      case 'name': return answers.name.trim().length > 0
+      case 'language': return !!answers.language
+      case 'keyboard': return !!answers.keyboard
+      case 'editor': return true
+      case 'done': return true
+      default: return true
+    }
+  })()
+
+  const goPrev = () => {
+    if (step > 0) setStep(step - 1)
+  }
+
+  useEffect(() => {
+    const handler = (e) => {
+      if (e.key === 'Escape') { goPrev(); return }
+      if (e.key === 'Enter' && current.key !== 'done') { e.preventDefault(); goNext() }
+    }
+    window.addEventListener('keydown', handler)
+    return () => window.removeEventListener('keydown', handler)
+  }, [step, current])
+
+  useEffect(() => {
+    if (current.key === 'done' && !saving) {
+      handleSave()
+    }
+  }, [step])
+
+  const handleSave = async () => {
+    setSaving(true)
+    setError(null)
+    try {
+      await api.saveProfile({
+        name: answers.name,
+        pseudo: answers.name.split(' ')[0] || 'user',
+        editor: answers.editor,
+      })
+      await api.savePreferences({
+        language: answers.language,
+        keyboard_layout: answers.keyboard,
+      })
+      onComplete()
+    } catch (err) {
+      setError(err.message || 'Erreur lors de la sauvegarde')
+      setSaving(false)
+    }
+  }
+
+  return (
+    <div className="onboarding-overlay">
+      <div className="onboarding-card">
+        <div className="onboarding-header">
+          <Sparkles size={20} style={{ color: 'var(--accent)' }} />
+          <span> Muyue Setup</span>
+        </div>
+
+        <div className="onboarding-progress">
+          {STEPS.map((_, i) => (
+            <div key={i} className={`onboarding-dot ${i === step ? 'active' : ''} ${i < step ? 'done' : ''}`} />
+          ))}
+        </div>
+
+        <div className="onboarding-body">
+          {current.key === 'welcome' && (
+            <div className="onboarding-step">
+              <div className="onboarding-title">Bienvenue ! 👋</div>
+              <div className="onboarding-desc">
+                Je suis votre assistant de configuration. Quelques questions rapides pour personnaliser votre expérience.
+              </div>
+            </div>
+          )}
+
+          {current.key === 'name' && (
+            <div className="onboarding-step">
+              <div className="onboarding-title">Comment vous appelez-vous ?</div>
+              <input
+                className="onboarding-input"
+                placeholder="Votre nom..."
+                value={answers.name}
+                onChange={e => { setAnswers(a => ({ ...a, name: e.target.value })); setRequiredError(false) }}
+                autoFocus
+              />
+              {requiredError && <div className="onboarding-required">Veuillez entrer votre nom</div>}
+            </div>
+          )}
+
+          {current.key === 'language' && (
+            <div className="onboarding-step">
+              <div className="onboarding-title">Quelle langue pr\u00e9f\u00e9rez-vous ?</div>
+              <div className="onboarding-chips">
+                {LANGUAGES.map(lang => (
+                  <div
+                    key={lang.id}
+                    className={`chip ${answers.language === lang.id ? 'active' : ''}`}
+                    onClick={() => setAnswers(a => ({ ...a, language: lang.id }))}
+                  >
+                    {lang.name}
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          {current.key === 'keyboard' && (
+            <div className="onboarding-step">
+              <div className="onboarding-title">Disposition du clavier ?</div>
+              <div className="onboarding-chips">
+                {layouts.map(l => (
+                  <div
+                    key={l.id}
+                    className={`chip ${answers.keyboard === l.id ? 'active' : ''}`}
+                    onClick={() => setAnswers(a => ({ ...a, keyboard: l.id }))}
+                  >
+                    {l.name}
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          {current.key === 'editor' && (
+            <div className="onboarding-step">
+              <div className="onboarding-title">Quel \u00e9diteur utilisez-vous ?</div>
+              <div className="onboarding-chips">
+                {EDITOR_SUGGESTIONS.map(ed => (
+                  <div
+                    key={ed}
+                    className={`chip ${answers.editor === ed ? 'active' : ''}`}
+                    onClick={() => setAnswers(a => ({ ...a, editor: ed }))}
+                  >
+                    {ed}
+                  </div>
+                ))}
+              </div>
+              <input
+                className="onboarding-input"
+                style={{ marginTop: 12 }}
+                placeholder="Autre (vim, nvim, vscode...)"
+                value={answers.editor}
+                onChange={e => setAnswers(a => ({ ...a, editor: e.target.value }))}
+                autoFocus
+              />
+            </div>
+          )}
+
+          {current.key === 'done' && (
+            <div className="onboarding-step">
+              {saving ? (
+                <>
+                  <div className="onboarding-title">Configuration en cours...</div>
+                  <div className="onboarding-desc">Sauvegarde de vos préférences.</div>
+                </>
+              ) : error ? (
+                <>
+                  <div className="onboarding-title" style={{ color: 'var(--error)' }}>Erreur</div>
+                  <div className="onboarding-desc" style={{ color: 'var(--error)' }}>{error}</div>
+                  <button className="primary" style={{ alignSelf: 'flex-start', marginTop: 8 }} onClick={() => handleSave()}>Réessayer</button>
+                </>
+              ) : (
+                <>
+                  <div className="onboarding-title">C'est parti ! 🚀</div>
+                  <div className="onboarding-desc">
+                    Votre profil est configuré. Vous pouvez toujours ajuster les paramètres dans l'onglet Configuration.
+                  </div>
+                </>
+              )}
+            </div>
+          )}
+        </div>
+
+        <div className="onboarding-footer">
+          {step > 0 && step < STEPS.length - 1 && (
+            <button className="ghost" onClick={goPrev}>
+              <ArrowLeft size={14} /> Précédent
+            </button>
+          )}
+          <div style={{ flex: 1 }} />
+          {step < STEPS.length - 1 && (
+            <button className="primary" onClick={goNext}>
+              Suivant <ArrowRight size={14} />
+            </button>
+          )}
+          {step === STEPS.length - 1 && !saving && !error && (
+            <button className="primary" onClick={handleSave}>
+              Commencer
+            </button>
+          )}
+        </div>
+      </div>
+
+      <style>{`
+        .onboarding-overlay {
+          position: fixed; inset: 0; z-index: 500;
+          background: rgba(10,10,12,0.85);
+          display: flex; align-items: center; justify-content: center;
+          backdrop-filter: blur(8px);
+        }
+        .onboarding-card {
+          background: var(--bg-elevated);
+          border: 1px solid var(--border);
+          border-radius: var(--radius-lg);
+          width: 480px; max-width: 90vw;
+          box-shadow: 0 24px 64px rgba(0,0,0,0.5);
+          overflow: hidden;
+        }
+        .onboarding-header {
+          display: flex; align-items: center; gap: 8px;
+          padding: 16px 20px; font-size: 14px; font-weight: 700;
+          color: var(--accent); border-bottom: 1px solid var(--border);
+          background: var(--bg-surface);
+        }
+        .onboarding-progress {
+          display: flex; gap: 6px; padding: 14px 20px;
+          background: var(--bg-surface);
+          border-bottom: 1px solid var(--border);
+        }
+        .onboarding-dot {
+          width: 32px; height: 4px; border-radius: 2px;
+          background: var(--bg-input); transition: all 0.3s;
+        }
+        .onboarding-dot.active { background: var(--accent); }
+        .onboarding-dot.done { background: var(--accent-dim); }
+        .onboarding-body { padding: 28px 24px; min-height: 200px; }
+        .onboarding-step { display: flex; flex-direction: column; gap: 16px; }
+        .onboarding-title { font-size: 18px; font-weight: 700; color: var(--text-primary); }
+        .onboarding-desc { font-size: 14px; color: var(--text-tertiary); line-height: 1.6; }
+        .onboarding-input {
+          width: 100%; background: var(--bg-input); border: 1px solid var(--border);
+          border-radius: var(--radius); padding: 10px 14px; color: var(--text-primary);
+          font-size: 14px; outline: none; transition: border-color 0.2s, box-shadow 0.2s;
+        }
+        .onboarding-input:focus { border-color: var(--accent); box-shadow: 0 0 0 3px var(--border-accent); }
+        .onboarding-chips { display: flex; gap: 8px; flex-wrap: wrap; }
+        .onboarding-footer {
+          display: flex; justify-content: flex-end; gap: 8px;
+          padding: 16px 20px; border-top: 1px solid var(--border);
+          background: var(--bg-surface);
+        }
+        .onboarding-required {
+          font-size: 12px; color: var(--error); margin-top: 4px;
+        }
+      `}</style>
+    </div>
+  )
+}

web/src/components/Shell.jsx

@@ -8,37 +8,74 @@ import { useI18n } from '../i18n'
 
 const MAX_TABS = 7
 
-const XTERM_THEME = {
-  background: '#0A0A0C',
-  foreground: '#EAE0E2',
-  cursor: '#FF0033',
-  cursorAccent: '#0A0A0C',
-  selectionBackground: '#FF003344',
-  selectionForeground: '#ffffff',
-  black: '#0A0A0C',
-  red: '#FF0033',
-  green: '#00E676',
-  yellow: '#FFD740',
-  blue: '#448AFF',
-  magenta: '#FF1A5E',
-  cyan: '#00BCD4',
-  white: '#EAE0E2',
-  brightBlack: '#5A4F52',
-  brightRed: '#FF5252',
-  brightGreen: '#69F0AE',
-  brightYellow: '#FFFF00',
-  brightBlue: '#82B1FF',
-  brightMagenta: '#FF80AB',
-  brightCyan: '#84FFFF',
-  brightWhite: '#FFFFFF',
+const THEMES = {
+  default: {
+    background: '#0A0A0C', foreground: '#EAE0E2', cursor: '#FF0033',
+    cursorAccent: '#0A0A0C', selectionBackground: '#FF003344', selectionForeground: '#ffffff',
+    black: '#0A0A0C', red: '#FF0033', green: '#00E676', yellow: '#FFD740',
+    blue: '#448AFF', magenta: '#FF1A5E', cyan: '#00BCD4', white: '#EAE0E2',
+    brightBlack: '#5A4F52', brightRed: '#FF5252', brightGreen: '#69F0AE',
+    brightYellow: '#FFFF00', brightBlue: '#82B1FF', brightMagenta: '#FF80AB',
+    brightCyan: '#84FFFF', brightWhite: '#FFFFFF',
+  },
+  monokai: {
+    background: '#272822', foreground: '#F8F8F2', cursor: '#F8F8F0',
+    cursorAccent: '#272822', selectionBackground: '#F8F8F244', selectionForeground: '#ffffff',
+    black: '#272822', red: '#F92672', green: '#A6E22E', yellow: '#E6DB74',
+    blue: '#66D9EF', magenta: '#AE81FF', cyan: '#A1EFE4', white: '#F8F8F2',
+    brightBlack: '#75715E', brightRed: '#F92672', brightGreen: '#A6E22E',
+    brightYellow: '#E6DB74', brightBlue: '#66D9EF', brightMagenta: '#AE81FF',
+    brightCyan: '#A1EFE4', brightWhite: '#F8F8F2',
+  },
+  gruvbox: {
+    background: '#282828', foreground: '#EBDBB2', cursor: '#FB4934',
+    cursorAccent: '#282828', selectionBackground: '#EBDBB244', selectionForeground: '#ffffff',
+    black: '#282828', red: '#CC241D', green: '#98971A', yellow: '#D79921',
+    blue: '#458588', magenta: '#B16286', cyan: '#689D6A', white: '#EBDBB2',
+    brightBlack: '#928374', brightRed: '#FB4934', brightGreen: '#B8BB26',
+    brightYellow: '#FABC2A', brightBlue: '#83A598', brightMagenta: '#D3869B',
+    brightCyan: '#8EC07C', brightWhite: '#EBDBB2',
+  },
+  nord: {
+    background: '#2E3440', foreground: '#D8DEE9', cursor: '#D8DEE9',
+    cursorAccent: '#2E3440', selectionBackground: '#D8DEE944', selectionForeground: '#ffffff',
+    black: '#2E3440', red: '#BF616A', green: '#A3BE8C', yellow: '#EBCB8B',
+    blue: '#81A1C1', magenta: '#B48EAD', cyan: '#88C0D0', white: '#D8DEE9',
+    brightBlack: '#4C566A', brightRed: '#BF616A', brightGreen: '#A3BE8C',
+    brightYellow: '#EBCB8B', brightBlue: '#81A1C1', brightMagenta: '#B48EAD',
+    brightCyan: '#8FBCBB', brightWhite: '#ECEFF4',
+  },
+  'solarized-dark': {
+    background: '#002B36', foreground: '#839496', cursor: '#D33682',
+    cursorAccent: '#002B36', selectionBackground: '#83949644', selectionForeground: '#ffffff',
+    black: '#002B36', red: '#DC322F', green: '#859900', yellow: '#B58900',
+    blue: '#268BD2', magenta: '#D33682', cyan: '#2AA198', white: '#FDF6E3',
+    brightBlack: '#073642', brightRed: '#CB4B16', brightGreen: '#586E75',
+    brightYellow: '#657B83', brightBlue: '#6C71C4', brightMagenta: '#6C71C4',
+    brightCyan: '#93A1A1', brightWhite: '#FDF6E3',
+  },
+  dracula: {
+    background: '#282A36', foreground: '#F8F8F2', cursor: '#F8F8F2',
+    cursorAccent: '#282A36', selectionBackground: '#F8F8F244', selectionForeground: '#ffffff',
+    black: '#282A36', red: '#FF5555', green: '#50FA7B', yellow: '#F1FA8C',
+    blue: '#BD93F9', magenta: '#FF79C6', cyan: '#8BE9FD', white: '#F8F8F2',
+    brightBlack: '#6272A4', brightRed: '#FF6E6E', brightGreen: '#69FF94',
+    brightYellow: '#FFFFA5', brightBlue: '#D6ACFF', brightMagenta: '#FF92DF',
+    brightCyan: '#A4FFFF', brightWhite: '#FFFFFF',
+  },
 }
 
-function createTerminal(container) {
+function getTheme(themeName) {
+  return THEMES[themeName] || THEMES.default
+}
+
+function createTerminal(container, settings = {}) {
+  const theme = getTheme(settings.theme || 'default')
   const term = new XTerm({
     cursorBlink: true,
-    fontSize: 14,
-    fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'SF Mono', 'Menlo', monospace",
-    theme: XTERM_THEME,
+    fontSize: settings.fontSize || 14,
+    fontFamily: settings.fontFamily || "'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'SF Mono', 'Menlo', monospace",
+    theme,
     allowTransparency: false,
     scrollback: 5000,
   })
@@ -57,15 +94,15 @@ function connectWebSocket(term, fitAddon, initPayload) {
   const proto = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
   const ws = new WebSocket(`${proto}//${window.location.host}/api/ws/terminal`)
 
-  ws.onopen = () => {
+  ws.addEventListener('open', () => {
     ws.send(JSON.stringify(initPayload))
     const dims = fitAddon.proposeDimensions()
     if (dims) {
       ws.send(JSON.stringify({ type: 'resize', rows: dims.rows, cols: dims.cols }))
     }
-  }
+  })
 
-  ws.onmessage = (event) => {
+  ws.addEventListener('message', (event) => {
     try {
       const msg = JSON.parse(event.data)
       if (msg.type === 'output') {
@@ -76,15 +113,15 @@ function connectWebSocket(term, fitAddon, initPayload) {
     } catch {
       term.write(event.data)
     }
-  }
+  })
 
-  ws.onclose = () => {
+  ws.addEventListener('close', () => {
     term.write('\r\n\x1b[33m— Connection closed —\x1b[0m\r\n')
-  }
+  })
 
-  ws.onerror = () => {
+  ws.addEventListener('error', () => {
     term.write('\r\n\x1b[31m— Connection error —\x1b[0m\r\n')
-  }
+  })
 
   term.onData((data) => {
     if (ws.readyState === WebSocket.OPEN) {
@@ -116,6 +153,11 @@ export default function Shell({ api }) {
   const [showSshModal, setShowSshModal] = useState(false)
   const [editingTab, setEditingTab] = useState(null)
   const [editName, setEditName] = useState('')
+  const [terminalSettings, setTerminalSettings] = useState({
+    fontSize: 14,
+    fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'SF Mono', 'Menlo', monospace",
+    theme: 'default',
+  })
 
   const [sshForm, setSshForm] = useState({
     name: '', host: '', port: 22, user: '', key_path: '',
@@ -137,6 +179,15 @@ export default function Shell({ api }) {
       setSshConnections(d.ssh || [])
       setSystemTerminals(d.system || [])
     }).catch(() => {})
+    api.getConfig().then(d => {
+      if (d.terminal) {
+        setTerminalSettings({
+          fontSize: d.terminal.font_size || 14,
+          fontFamily: d.terminal.font_family || "'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'SF Mono', 'Menlo', monospace",
+          theme: d.terminal.theme || 'default',
+        })
+      }
+    }).catch(() => {})
   }, [])
 
   const initTerminal = useCallback((tabId, tab) => {
@@ -145,7 +196,11 @@ export default function Shell({ api }) {
     const container = document.getElementById(`terminal-${tabId}`)
     if (!container) return
 
-    const { term, fitAddon } = createTerminal(container)
+    const { term, fitAddon } = createTerminal(container, {
+      fontSize: terminalSettings.fontSize,
+      fontFamily: terminalSettings.fontFamily,
+      theme: terminalSettings.theme,
+    })
 
     let initPayload
     if (tab.type === 'ssh') {
@@ -195,15 +250,25 @@ export default function Shell({ api }) {
 
   useEffect(() => {
     const tab = tabs.find(t => t.id === activeTab)
-    if (tab && !tabsRef.current[tab.id]) {
-      const timer = setTimeout(() => initTerminal(tab.id, tab), 50)
-      return () => clearTimeout(timer)
-    } else if (tab && tabsRef.current[tab.id]) {
+    if (!tab) return
+
+    const container = document.getElementById(`terminal-${tab.id}`)
+    if (!container) return
+
+    if (!tabsRef.current[tab.id]) {
       const timer = setTimeout(() => {
-        const { fitAddon } = tabsRef.current[tab.id]
-        fitAddon.fit()
-      }, 50)
+        initTerminal(tab.id, tab)
+        requestAnimationFrame(() => {
+          const entry = tabsRef.current[tab.id]
+          if (entry) entry.fitAddon.fit()
+        })
+      }, 100)
       return () => clearTimeout(timer)
+    } else {
+      requestAnimationFrame(() => {
+        const entry = tabsRef.current[tab.id]
+        if (entry) entry.fitAddon.fit()
+      })
     }
   }, [activeTab, tabs, initTerminal])
 
@@ -315,13 +380,61 @@ export default function Shell({ api }) {
     setAiLoading(true)
     try {
       const res = await api.runCommand(`echo "AI: ${text}"`, '')
-      setAiMessages(prev => [...prev, { role: 'ai', content: res.output || t('shell.noResponse') }])
+      const output = res.output || t('shell.noResponse')
+      parseAndAddAiMessages(output)
     } catch (err) {
       setAiMessages(prev => [...prev, { role: 'ai', content: `${t('shell.error')}: ${err.message}` }])
     }
     setAiLoading(false)
   }
 
+  const parseAndAddAiMessages = (text) => {
+    const lines = text.split('\n')
+    let buffer = ''
+    let inBlock = false
+
+    const flushBuffer = () => {
+      if (buffer.trim()) {
+        setAiMessages(prev => [...prev, { role: 'ai', content: buffer.trim() }])
+      }
+      buffer = ''
+    }
+
+    for (const line of lines) {
+      const toolMatch = line.match(/^\[TOOL_CALL:\{.*\}\]$/)
+      if (toolMatch) {
+        flushBuffer()
+        try {
+          const toolData = JSON.parse(toolMatch[0].slice(10, -1))
+          setAiMessages(prev => [...prev, {
+            role: 'tool',
+            content: `${t('shell.toolLaunched')}: ${toolData.tool || 'tool'}`,
+            args: toolData.task || toolData.args || '',
+          }])
+        } catch {
+          setAiMessages(prev => [...prev, { role: 'tool', content: line, args: '' }])
+        }
+      } else if (line.match(/^(Reflexion|Thought|thinking):/i) || line.startsWith('>')) {
+        if (buffer.trim() && !inBlock) {
+          flushBuffer()
+        }
+        inBlock = true
+        const cleaned = line.replace(/^(Reflexion|Thought|thinking):\s*/i, '').replace(/^>\s*/, '')
+        if (buffer) buffer += ' '
+        buffer += cleaned
+      } else {
+        if (inBlock && buffer.trim()) {
+          setAiMessages(prev => [...prev, { role: 'thinking', content: buffer.trim() }])
+          buffer = ''
+        }
+        inBlock = false
+        if (buffer) buffer += '\n'
+        buffer += line
+      }
+    }
+    flushBuffer()
+  }
+
   return (
     <div className="shell-layout">
       <div className="shell-terminal-col">
@@ -442,6 +555,7 @@ export default function Shell({ api }) {
           {aiMessages.map((msg, i) => (
             <div key={i} className={`ai-message ${msg.role}`}>
               {msg.content}
+              {msg.args && <div className="tool-args">{msg.args}</div>}
             </div>
           ))}
           {aiLoading && <div style={{ textAlign: 'center', padding: 8 }}><span className="spinner" /></div>}

web/src/components/Studio.jsx

@@ -1,6 +1,35 @@
 import { useState, useRef, useEffect, useCallback } from 'react'
 import { useI18n } from '../i18n'
 
+const RANKS = {
+  commandant: { label: 'Commandant', short: 'CDT', color: '#FFD740' },
+  general:    { label: 'General',    short: 'GEN', color: '#FF9100' },
+  colonel:    { label: 'Colonel',    short: 'COL', color: '#FF6D00' },
+  lieutenant: { label: 'Lieutenant', short: 'LT',  color: '#448AFF' },
+  soldat:     { label: 'Soldat',     short: 'SDT', color: '#00E676' },
+}
+
+function getRank(role) {
+  if (role === 'user') return RANKS.commandant
+  if (role === 'system') return null
+  return RANKS.general
+}
+
+function RankIcon({ rank }) {
+  if (rank === RANKS.commandant) {
+    return (
+      <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke={rank.color} strokeWidth="2">
+        <polygon points="12,2 15.09,8.26 22,9.27 17,14.14 18.18,21.02 12,17.77 5.82,21.02 7,14.14 2,9.27 8.91,8.26"/>
+      </svg>
+    )
+  }
+  return (
+    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke={rank.color} strokeWidth="2">
+      <path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/>
+    </svg>
+  )
+}
+
 function renderContent(text) {
   const parts = []
   const codeBlockRegex = /(```[\s\S]*?```)/g
@@ -34,17 +63,25 @@ function formatText(text) {
     .replace(/^\s*(\d+)[.)] (.+)$/gm, '<span class="msg-step"><span class="msg-step-num">$1</span>$2</span>')
 }
 
+function ThinkingBlock({ content, done }) {
+  return (
+    <div className={`feed-thinking-block ${done ? 'done' : 'active'}`}>
+      <div className="feed-thinking-header">
+        <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+          <circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/>
+        </svg>
+        <span>Reflexion</span>
+        {!done && <span className="feed-thinking-dots"><span/><span/><span/></span>}
+      </div>
+      <div className="feed-thinking-content">{content}</div>
+    </div>
+  )
+}
+
 function FeedItem({ msg }) {
   const isUser = msg.role === 'user'
   const isSystem = msg.role === 'system'
-
-  const roleLabel = isUser ? null : isSystem ? null : (
-    <div className="feed-avatar">
-      <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-        <path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/>
-      </svg>
-    </div>
-  )
+  const rank = getRank(msg.role)
 
   const timeStr = msg.time ? new Date(msg.time).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : ''
 
@@ -58,16 +95,24 @@ function FeedItem({ msg }) {
     )
   }
 
+  const cleanContent = msg.content.replace(/<think[^>]*>[\s\S]*?<\/think>/gi, '')
+
   return (
     <div className={`feed-item ${msg.role}`}>
-      {roleLabel}
+      <div className={`feed-avatar ${isUser ? 'user-rank' : 'ai-rank'}`}>
+        <RankIcon rank={rank} />
+      </div>
       <div className="feed-body">
         <div className="feed-header">
-          <span className="feed-role">{isUser ? 'Vous' : 'IA'}</span>
+          <span className="feed-rank-badge" style={{ color: rank.color, borderColor: rank.color }}>
+            {rank.short}
+          </span>
+          <span className="feed-role">{rank.label}</span>
           {timeStr && <span className="feed-time">{timeStr}</span>}
         </div>
+        {msg.thinking && <ThinkingBlock content={msg.thinking} done />}
         <div className="feed-content">
-          {renderContent(msg.content).map((part, i) =>
+          {renderContent(cleanContent).map((part, i) =>
             part.type === 'code' ? (
               <div key={i} className="studio-code-block">
                 {part.lang && <div className="studio-code-lang">{part.lang}</div>}
@@ -83,31 +128,43 @@ function FeedItem({ msg }) {
   )
 }
 
-function StreamingItem({ content }) {
+function StreamingItem({ content, thinking }) {
+  const rank = RANKS.general
+  const cleanContent = content.replace(/<think[^>]*>[\s\S]*?<\/think>/gi, '')
+
   return (
     <div className="feed-item assistant">
-      <div className="feed-avatar">
-        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-          <path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/>
-        </svg>
+      <div className="feed-avatar ai-rank">
+        <RankIcon rank={rank} />
       </div>
       <div className="feed-body">
         <div className="feed-header">
-          <span className="feed-role">IA</span>
-        </div>
-        <div className="feed-content">
-          {renderContent(content).map((part, i) =>
-            part.type === 'code' ? (
-              <div key={i} className="studio-code-block">
-                {part.lang && <div className="studio-code-lang">{part.lang}</div>}
-                <pre><code>{part.content}</code></pre>
-              </div>
-            ) : (
-              <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
-            )
-          )}
-          <span className="studio-cursor" />
+          <span className="feed-rank-badge" style={{ color: rank.color, borderColor: rank.color }}>
+            {rank.short}
+          </span>
+          <span className="feed-role">{rank.label}</span>
         </div>
+        {thinking && <ThinkingBlock content={thinking} done={false} />}
+        {!thinking && !cleanContent && (
+          <div className="feed-content">
+            <div className="studio-thinking"><span /><span /><span /></div>
+          </div>
+        )}
+        {cleanContent && (
+          <div className="feed-content">
+            {renderContent(cleanContent).map((part, i) =>
+              part.type === 'code' ? (
+                <div key={i} className="studio-code-block">
+                  {part.lang && <div className="studio-code-lang">{part.lang}</div>}
+                  <pre><code>{part.content}</code></pre>
+                </div>
+              ) : (
+                <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
+              )
+            )}
+            <span className="studio-cursor" />
+          </div>
+        )}
       </div>
     </div>
   )
@@ -119,6 +176,7 @@ export default function Studio({ api }) {
   const [input, setInput] = useState('')
   const [loading, setLoading] = useState(false)
   const [streaming, setStreaming] = useState('')
+  const [streamThinking, setStreamThinking] = useState('')
   const [loaded, setLoaded] = useState(false)
   const messagesEnd = useRef(null)
   const textareaRef = useRef(null)
@@ -143,7 +201,7 @@ export default function Studio({ api }) {
 
   useEffect(() => {
     messagesEnd.current?.scrollIntoView({ behavior: 'smooth' })
-  }, [messages, streaming])
+  }, [messages, streaming, streamThinking])
 
   useEffect(() => {
     if (textareaRef.current) {
@@ -175,20 +233,33 @@ export default function Studio({ api }) {
     setMessages(prev => [...prev, userMsg])
     setLoading(true)
     setStreaming('')
+    setStreamThinking('')
 
     try {
       let accumulated = ''
-      await api.sendChat(text, true).then(full => {
-        accumulated = full
-      }).catch(() => {})
+      let thinking = ''
+
+      await api.sendChat(text, true, (partial, event) => {
+        if (event && (event.thinking_start || event.thinking_end || event.thinking !== undefined)) {
+          if (event.thinking !== undefined) {
+            thinking += event.thinking
+            setStreamThinking(thinking)
+          }
+          return
+        }
+        accumulated = partial
+        setStreaming(partial)
+      })
 
       const finalContent = accumulated || t('studio.noResponse')
-      setMessages(prev => [...prev, {
+      const aiMsg = {
         id: (Date.now() + 1).toString(),
         role: 'assistant',
         content: finalContent,
         time: new Date().toISOString(),
-      }])
+      }
+      if (thinking) aiMsg.thinking = thinking
+      setMessages(prev => [...prev, aiMsg])
     } catch (err) {
       setMessages(prev => [...prev, {
         id: (Date.now() + 1).toString(),
@@ -199,6 +270,7 @@ export default function Studio({ api }) {
     } finally {
       setLoading(false)
       setStreaming('')
+      setStreamThinking('')
     }
   }, [input, loading, api, t, handleClear])
 
@@ -227,20 +299,8 @@ export default function Studio({ api }) {
         {messages.map(msg => (
           <FeedItem key={msg.id} msg={msg} />
         ))}
-        {streaming && <StreamingItem content={streaming} />}
-        {loading && !streaming && (
-          <div className="feed-item assistant">
-            <div className="feed-avatar">
-              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
-                <path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/>
-              </svg>
-            </div>
-            <div className="feed-body">
-              <div className="feed-content">
-                <div className="studio-thinking"><span /><span /><span /></div>
-              </div>
-            </div>
-          </div>
+        {(streaming || streamThinking || loading) && (
+          <StreamingItem content={streaming} thinking={streamThinking} />
         )}
         <div ref={messagesEnd} />
       </div>

web/src/i18n/en.js

@@ -81,10 +81,6 @@ const en = {
 
   shell: {
     terminal: 'Terminal',
-    hideAi: 'Hide AI',
-    aiAssistant: 'AI Assistant',
-    aiWelcome: 'I know your system inside out. Ask me anything.',
-    askAi: 'Ask AI...',
     send: 'Send',
     noResponse: 'No response',
     error: 'Error',
@@ -111,15 +107,21 @@ const en = {
     systemTerminals: 'System terminals',
     switchTerminal: 'Switch terminal',
     localShell: 'Local Shell',
+    aiAssistant: 'AI Assistant',
+    aiWelcome: 'Hello! I can help you with terminal commands. Ask me anything!',
+    askAi: 'Ask AI assistant...',
+    toolLaunched: 'Tool launched',
   },
 
   config: {
     panels: {
       profile: 'Profile',
       providers: 'AI Providers',
+      terminal: 'Terminal',
       updates: 'Updates',
       locale: 'Language & Keyboard',
       skills: 'Skills',
+      system: 'System',
     },
     profile: 'Profile',
     name: 'Name',
@@ -166,6 +168,25 @@ const en = {
     editProfile: 'Edit',
     cancel: 'Cancel',
     editProvider: 'Configure',
+    validateKey: 'Validate',
+    validating: 'Validating...',
+    keyValid: 'Valid key',
+    keyInvalid: 'Invalid key',
+    connectionFailed: 'Connection failed',
+    enterToken: 'Enter your API token for {provider}',
+    tokenPlaceholder: 'sk-...',
+    setupDescription: 'Configure your AI provider token to use the assistant.',
+    terminalTheme: 'Terminal Theme',
+    fontSize: 'Font Size',
+    fontFamily: 'Font Family',
+    preview: 'Preview',
+    saving: 'Saving...',
+    resetConfig: 'Reset all',
+    resetConfirm: 'Are you sure? All preferences will be erased.',
+    resetDone: 'Settings reset.',
+    applyStarship: 'Apply starship',
+    starshipApplied: 'Starship theme applied! Restart your shell to see the result.',
+    starshipError: 'Failed to apply starship theme.',
   },
 }
 

web/src/i18n/fr.js

@@ -81,10 +81,6 @@ const fr = {
 
   shell: {
     terminal: 'Terminal',
-    hideAi: 'Masquer IA',
-    aiAssistant: 'Assistant IA',
-    aiWelcome: 'Je connais votre syst\u00e8me sur le bout des doigts. Demandez-moi n\u2019importe quoi.',
-    askAi: 'Demander \u00e0 l\u2019IA...',
     send: 'Envoyer',
     noResponse: 'Pas de r\u00e9ponse',
     error: 'Erreur',
@@ -111,15 +107,21 @@ const fr = {
     systemTerminals: 'Terminaux syst\u00e8me',
     switchTerminal: 'Changer de terminal',
     localShell: 'Shell local',
+    aiAssistant: 'Assistant IA',
+    aiWelcome: 'Bonjour ! Je peux vous aider avec les commandes du terminal. Demandez-moi n\'importe quoi !',
+    askAi: 'Interroger l\'assistant IA...',
+    toolLaunched: 'Outil lanc\u00e9',
   },
 
   config: {
     panels: {
       profile: 'Profil',
       providers: 'Fournisseurs IA',
+      terminal: 'Terminal',
       updates: 'Mises \u00e0 jour',
       locale: 'Langue & Clavier',
-      skills: 'Comp\u00e9tences',
+      skills: 'Comp\u00e9ENCES',
+      system: 'Syst\u00e8me',
     },
     profile: 'Profil',
     name: 'Nom',
@@ -142,7 +144,7 @@ const fr = {
     save: 'Enregistrer',
     saved: 'Enregistr\u00e9 !',
     error: 'Erreur',
-    skills: 'Comp\u00e9tences',
+    skills: 'Comp\u00e9ENCES',
     noSkills: 'Aucune comp\u00e9tence install\u00e9e.',
     runSkillsInit: 'Ex\u00e9cutez muyue skills init',
     language: 'Langue',
@@ -165,7 +167,26 @@ const fr = {
     missing: 'Manquant',
     editProfile: 'Modifier',
     editProvider: 'Configurer',
+    validateKey: 'Valider',
+    validating: 'V\u00e9rification...',
+    keyValid: 'Cl\u00e9 valide',
+    keyInvalid: 'Cl\u00e9 invalide',
+    connectionFailed: 'Connexion \u00e9chou\u00e9e',
+    enterToken: 'Entrez votre token API pour {provider}',
+    tokenPlaceholder: 'sk-...',
+    setupDescription: 'Configurez le token de votre fournisseur IA pour utiliser l\'assistant.',
     cancel: 'Annuler',
+    terminalTheme: 'Th\u00e8me du terminal',
+    fontSize: 'Taille de police',
+    fontFamily: 'Police',
+    preview: 'Aper\u00e7u',
+    saving: 'Enregistrement...',
+    resetConfig: 'R\u00e9initialiser',
+    resetConfirm: '\u00cates-vous s\u00fbr ? Toutes les pr\u00e9f\u00e9rences seront effac\u00e9es.',
+    resetDone: 'Param\u00e8tres r\u00e9initialis\u00e9s.',
+    applyStarship: 'Appliquer starship',
+    starshipApplied: 'Th\u00e8me starship appliqu\u00e9 ! Red\u00e9marrez votre shell pour voir le r\u00e9sultat.',
+    starshipError: '\u00c9chec de l\u2019application du th\u00e8me starship.',
   },
 }
 

web/src/styles/global.css

@@ -269,7 +269,7 @@ input::placeholder { color: var(--text-disabled); }
 .sidebar-tab.active { background: var(--accent); color: #fff; font-weight: 600; }
 
 .shell-layout { display: flex; height: 100%; }
-.shell-terminal-col { flex: 1; display: flex; flex-direction: column; min-width: 0; }
+.shell-terminal-col { flex: 1; display: flex; flex-direction: column; min-width: 0; min-height: 0; overflow: hidden; }
 
 .shell-tabs-bar {
   display: flex; align-items: center; background: var(--bg-surface);
@@ -377,14 +377,27 @@ input::placeholder { color: var(--text-disabled); }
 .shell-xterm-wrapper { flex: 1; background: var(--bg); overflow: hidden; position: relative; }
 .shell-xterm-instance {
   position: absolute; inset: 0; padding: 4px;
+  display: block !important;
 }
 .shell-xterm-instance .xterm { height: 100%; padding: 4px; }
 
-.shell-ai-col { width: 340px; border-left: 1px solid var(--border); background: var(--bg-surface); display: flex; flex-direction: column; flex-shrink: 0; }
 .connection-dot { width: 8px; height: 8px; border-radius: 50%; display: inline-block; flex-shrink: 0; }
 .connection-dot.on { background: var(--success); box-shadow: 0 0 6px var(--success); }
 .connection-dot.off { background: var(--error); }
 
+.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-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.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); }
+.ai-message.tool .tool-args { font-family: var(--font-mono); font-size: 12px; color: var(--text-tertiary); margin-top: 4px; }
+.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-modal-overlay {
   position: fixed; inset: 0; background: rgba(0,0,0,0.6);
   display: flex; align-items: center; justify-content: center; z-index: 1000;
@@ -407,30 +420,14 @@ input::placeholder { color: var(--text-disabled); }
   display: flex; justify-content: flex-end; gap: 8px;
 }
 
-.config-window { display: flex; height: 100%; overflow: hidden; }
+.config-window { display: flex; flex-direction: column; height: 100%; overflow: hidden; }
 
-.config-sidebar {
-  width: 180px; background: var(--bg-surface); border-right: 1px solid var(--border);
-  display: flex; flex-direction: column; padding: 12px 8px; gap: 2px; flex-shrink: 0;
-  overflow-y: auto;
+.config-tabs-bar {
+  display: flex; gap: 4px; padding: 12px 20px 0; background: var(--bg-surface);
+  border-bottom: 1px solid var(--border); flex-shrink: 0;
 }
-.config-sidebar-item {
-  display: flex; align-items: center; gap: 10px; padding: 9px 12px;
-  border-radius: var(--radius); font-size: 13px; font-weight: 500;
-  color: var(--text-tertiary); cursor: pointer; transition: all 0.15s;
-  user-select: none;
-}
-.config-sidebar-item:hover { background: var(--bg-card); color: var(--text-primary); }
-.config-sidebar-item.active { background: var(--accent-bg); color: var(--accent); font-weight: 600; }
-.config-sidebar-item svg { flex-shrink: 0; }
 
 .config-panel-area { flex: 1; display: flex; flex-direction: column; overflow: hidden; }
-.config-panel-header {
-  padding: 20px 28px 0; flex-shrink: 0;
-}
-.config-panel-title {
-  font-size: 16px; font-weight: 700; color: var(--text-primary); margin: 0;
-}
 .config-panel-body { flex: 1; overflow-y: auto; padding: 16px 28px 28px; }
 
 .config-card {
@@ -475,6 +472,15 @@ input::placeholder { color: var(--text-disabled); }
 .provider-card-meta { display: flex; gap: 16px; font-size: 12px; color: var(--text-tertiary); font-family: var(--font-mono); margin-top: 8px; }
 .provider-card-form { margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border); }
 
+.provider-setup-hint {
+  font-size: 13px; color: var(--text-tertiary); margin-bottom: 16px;
+  padding: 10px 14px; border-radius: var(--radius); background: var(--bg-surface);
+  border-left: 3px solid var(--accent-dim);
+}
+.provider-setup-token-row { display: flex; gap: 12px; align-items: flex-end; }
+.provider-setup-token-input { flex: 1; }
+.provider-setup-token-actions { display: flex; gap: 8px; flex-shrink: 0; padding-bottom: 1px; }
+
 .config-update-controls {
   display: flex; align-items: center; justify-content: space-between; gap: 16px; flex-wrap: wrap;
 }
@@ -517,14 +523,6 @@ input::placeholder { color: var(--text-disabled); }
 .agent-name { font-weight: 600; color: var(--text-primary); font-size: 13px; }
 .agent-status { font-size: 11px; color: var(--text-tertiary); margin-top: 2px; }
 
-.ai-panel-header { padding: 12px 16px; border-bottom: 1px solid var(--border); font-weight: 700; font-size: 13px; color: var(--accent); }
-.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-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; }
-
 .empty-state { display: flex; flex-direction: column; align-items: center; justify-content: center; padding: 40px 20px; color: var(--text-disabled); font-size: 13px; text-align: center; gap: 8px; }
 
 .dashboard-layout { display: flex; flex-direction: column; height: 100%; }
@@ -585,14 +583,98 @@ input::placeholder { color: var(--text-disabled); }
 .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); }
-.feed-item.user { background: var(--bg-card); border-left: 3px solid var(--accent-muted); }
-.feed-item.assistant { }
+.feed-item.user { background: var(--bg-card); border-left: 3px solid #FFD740; }
+.feed-item.assistant { border-left: 3px solid transparent; }
+.feed-item.assistant:hover { border-left-color: var(--accent-dark); }
 .feed-item.system { align-items: center; gap: 8px; padding: 6px 12px; }
-.feed-avatar { width: 24px; height: 24px; border-radius: 50%; background: var(--accent-bg); color: var(--accent); display: flex; align-items: center; justify-content: center; flex-shrink: 0; margin-top: 2px; }
+.feed-avatar { width: 28px; height: 28px; border-radius: 50%; display: flex; align-items: center; justify-content: center; flex-shrink: 0; margin-top: 2px; font-size: 14px; }
+.feed-avatar.user-rank { background: rgba(255, 215, 64, 0.15); }
+.feed-avatar.ai-rank { background: var(--accent-bg); }
+.feed-rank-icon { display: flex; align-items: center; justify-content: center; }
 .feed-body { flex: 1; min-width: 0; }
 .feed-header { display: flex; align-items: center; gap: 8px; margin-bottom: 2px; }
+.feed-rank-badge {
+  font-size: 9px; font-weight: 800; font-family: var(--font-mono);
+  padding: 1px 6px; border-radius: 3px; border: 1px solid;
+  letter-spacing: 0.5px; text-transform: uppercase;
+  background: rgba(255, 215, 64, 0.08);
+}
 .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-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-thinking-block {
+  background: var(--bg-surface); border: 1px solid var(--border); border-left: 2px solid var(--accent-dim);
+  border-radius: var(--radius); margin: 6px 0 8px; overflow: hidden;
+  transition: all 0.3s ease;
+}
+.feed-thinking-block.active {
+  border-left-color: var(--warning);
+}
+.feed-thinking-block.done {
+  border-left-color: var(--text-disabled);
+  opacity: 0.7;
+}
+.feed-thinking-block.done .feed-thinking-content {
+  max-height: 80px;
+  overflow-y: auto;
+}
+.feed-thinking-header {
+  display: flex; align-items: center; gap: 6px;
+  padding: 6px 10px; font-size: 10px; font-weight: 700;
+  color: var(--text-tertiary); text-transform: uppercase; letter-spacing: 0.5px;
+  background: var(--bg-card); border-bottom: 1px solid var(--border);
+}
+.feed-thinking-header svg { color: var(--warning); }
+.feed-thinking-dots { display: inline-flex; gap: 2px; margin-left: 4px; }
+.feed-thinking-dots span { width: 4px; height: 4px; border-radius: 50%; background: var(--warning); animation: bounce 1.2s ease-in-out infinite; }
+.feed-thinking-dots span:nth-child(2) { animation-delay: 0.15s; }
+.feed-thinking-dots span:nth-child(3) { animation-delay: 0.3s; }
+.feed-thinking-content {
+  padding: 8px 10px; font-size: 12px; color: var(--text-tertiary);
+  font-style: italic; line-height: 1.5; max-height: 120px; overflow-y: auto;
+}
+
+.studio-code-block {
+  background: var(--bg); border: 1px solid var(--border); border-radius: var(--radius);
+  overflow: hidden; margin: 8px 0;
+}
+.studio-code-block pre { padding: 12px 16px; font-family: var(--font-mono); font-size: 13px; line-height: 1.5; overflow-x: auto; color: var(--text-primary); margin: 0; }
+.studio-code-lang {
+  padding: 4px 12px; font-size: 11px; font-weight: 600; color: var(--text-tertiary);
+  background: var(--bg-surface); border-bottom: 1px solid var(--border); text-transform: uppercase; letter-spacing: 0.5px;
+}
+.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-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-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; } }
+.studio-thinking { display: flex; gap: 4px; padding: 8px 0; }
+.studio-thinking span { width: 6px; height: 6px; border-radius: 50%; background: var(--accent-dim); animation: bounce 1.2s ease-in-out infinite; }
+.studio-thinking span:nth-child(2) { animation-delay: 0.15s; }
+.studio-thinking span:nth-child(3) { animation-delay: 0.3s; }
+@keyframes bounce { 0%, 80%, 100% { transform: translateY(0); opacity: 0.4; } 40% { transform: translateY(-6px); opacity: 1; } }
+.studio-input-area { padding: 12px 20px 8px; border-top: 1px solid var(--border); background: var(--bg-surface); }
+.studio-input-row { display: flex; gap: 8px; align-items: flex-end; }
+.studio-input-row textarea {
+  flex: 1; resize: none; min-height: 42px; max-height: 200px; padding: 10px 14px;
+  font-size: 14px; line-height: 1.5; border-radius: var(--radius);
+  background: var(--bg-input); color: var(--text-primary); border: 1px solid var(--border);
+  font-family: var(--font-sans); outline: none; transition: border-color 0.2s, box-shadow 0.2s;
+}
+.studio-input-row textarea:focus { border-color: var(--accent); box-shadow: 0 0 0 3px var(--border-accent); }
+.studio-input-row textarea::placeholder { color: var(--text-disabled); }
+.studio-send-btn {
+  width: 42px; height: 42px; padding: 0; display: flex; align-items: center; justify-content: center;
+  border-radius: var(--radius); background: var(--accent); color: #fff; border: 1px solid var(--accent);
+  cursor: pointer; transition: all 0.15s; flex-shrink: 0;
+}
+.studio-send-btn:hover:not(:disabled) { background: var(--accent-bright); border-color: var(--accent-bright); }
+.studio-send-btn:disabled { opacity: 0.3; cursor: not-allowed; }
+.studio-input-hint { font-size: 11px; color: var(--text-disabled); text-align: center; margin-top: 6px; }

web/vite.config.js

@@ -13,6 +13,7 @@ export default defineConfig({
       '/api': {
         target: 'http://127.0.0.1:8095',
         changeOrigin: true,
+        ws: true,
       },
     },
   },