Merge pull request 'release: v0.7.0 — Tests pilotés par l'IA' (#4) from release/v0.7.0 into develop

Reviewed-on: #4

CHANGELOG.md

@@ -4,6 +4,493 @@ 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.7.0
+
+### Nouvelle fonctionnalité majeure : Tests pilotés par l'IA
+
+- **Onglet Tests** dédié dans l'UI : génère un snippet JS à coller dans n'importe quelle page web ouverte (Chrome, Firefox, Edge, dev local ou distant).
+- **Session WebSocket** authentifiée par token à usage unique (5 min TTL) — la page connectée transmet ses messages console en temps réel et expose une RPC pour cliquer / évaluer / inspecter.
+- **Outil agent `browser_test`** disponible pour Studio, avec actions :
+  - `list_clickables` : énumère tous les éléments cliquables visibles avec un index stable
+  - `click` : clic par sélecteur CSS ou par index — retourne le **delta console** émis pendant le clic
+  - `eval` : évalue une expression JS et retourne sa valeur sérialisée
+  - `console` / `summary` : lit le buffer console (200 dernières entrées)
+  - `current_url` : URL et titre courants
+  - `type` : remplit un champ input/textarea (utilise le setter natif pour compatibilité React)
+  - `wait` : pause asynchrone (max 5s)
+- **Stratégie BMAD** intégrée au prompt système Studio : boucle `summary → list_clickables → click → vérifier console_delta → rapport final ✓/✗/⚠`.
+- **Multi-sessions** : jusqu'à 16 onglets connectés simultanément ; éviction LRU au-delà.
+- **Sécurité** : token consommé à la première connexion ; CheckOrigin libre côté snippet (gating par token uniquement) ; CORS API REST inchangé.
+- **Backend** : `internal/api/browser_test.go` (nouveau, ~480 lignes) + 4 routes (`/api/test/snippet`, `/api/test/sessions`, `/api/test/console/{id}`, `/api/ws/browser-test`).
+- **Frontend** : `web/src/components/Tests.jsx` (nouveau) + nouvel onglet ⌃4.
+
+## v0.6.0
+
+### Audit & corrections (sécurité, concurrence, stabilité)
+
+- fix(api): empty `resp.Choices[0]` panic in chat engine — bounded check
+- fix(api): `defer release()` accumulating inside tool-call loop — release immediately after each tool call
+- fix(api): race in `ConversationStoreMulti.Add` (fire-and-forget save under released lock) — synchronous save under existing lock
+- fix(workflow): infinite busy-wait in `engine.Execute` when a dependency fails — propagate `StatusFailed`/`StatusSkipped` and short-circuit
+- fix(workflow): UTF-8-unsafe slicing of plan goal — rune-aware truncate
+- fix(security): CORS `Access-Control-Allow-Origin: *` — restricted to localhost origins
+- fix(security): API key disclosure in `/api/providers` — masked as `"***"`; saving handler ignores `"***"` placeholder
+- fix(security): SSH password disclosure in `/api/terminal/sessions` — masked; update handler preserves stored password if `"***"` is sent
+- fix(security): sshpass `-p` + `-e` mutually-exclusive flags — use only `-e` with `SSHPASS` env var
+- fix(security): unbounded chat request body — `MaxBytesReader` 50 MB
+- fix(security): unbounded image upload — 10 MB cap in `saveImage`
+- fix(security): font size unbounded — capped at 72
+- fix(security): `LSP /auto-install` accepted arbitrary `project_dir` — restricted to user home subtree
+- fix(api): silent `json.Unmarshal` errors in profile save — propagated
+- fix(ui): operator-precedence bug in `Shell.jsx` resize check — parenthesized
+
+### Nouvelles fonctionnalités
+
+- feat(ai): inject OS name (e.g. `Debian 12`, `Windows 11`, `macOS 14.5`) alongside date in Studio system prompt
+- feat(agents): default timeout raised to 30 minutes for `crush_run` and `claude_run`; max also 30 min
+- feat(agents): new optional params `cwd`, `wsl_distro`, `wsl_user` — agents can be launched in a specific directory, and on Windows hosts inside a specific WSL distribution under a specific user
+- feat(agents): new `claude_run` tool (mirrors `crush_run` for the Claude Code CLI)
+- feat(terminal): WSL distros listed individually as quick-launch entries in the new-tab menu (Windows hosts only)
+- feat(studio): system prompt rewritten around the BMAD-METHOD (Analyst/PM/Architect/SM/Dev/QA personas + mandatory `[OBJECTIF]/[CONTEXTE]/[CONTRAINTES]/[LIVRABLE]/[CRITÈRE D'ACCEPTATION]` template for any agent delegation)
+- feat(studio): "Réflexion avancée" toggle — when enabled, the inactive AI provider produces a preliminary report that is injected as `[RAPPORT PRÉALABLE]` context into the active provider's prompt
+- feat(studio): "Historique compressé" toggle — collapses past tool calls and keeps only the last visible action per assistant message, with `Tout afficher` to expand
+
+### Bug fix CI
+
+- fix(test): `cleanAIResponse` → `CleanAIResponse` in `orchestrator_test.go` (was failing `go vet`)
+
+## v0.4.0
+
+### Changes since v0.3.5
+
+- fix: token persistence, context windows, CSS tables/bullets/hr, image attachments (12000e5)
+- feat: terminal sudo blocking, token tracking, mermaid & consumption UI (cb3d357)
+- fix(shell,config): terminal font size, AI tools, provider keys (0830e64)
+- chore: update CHANGELOG for v0.3.5 (b43e335)
+- fix(shell): set default terminal fontSize to 6px (a60435d)
+- fix(shell): default fontSize 10px and init new tabs immediately (6b0fcfb)
+- feat(shell): add Ctrl+/- zoom and display all shortcuts in footer (df46b5c)
+- fix(deps): upgrade @xterm/xterm to 6.1.0-beta.203 for addon compatibility (7240813)
+- fix(shell): enable allowProposedApi for Unicode11 addon (97bfb80)
+- fix(ci): add .npmrc with legacy-peer-deps for xterm addon resolution (3104179)
+- feat(shell): integrate Hyper-like terminal technologies (WebGL, search, unicode11, image) (e21b47a)
+- fix(shell): restore all missing imports, constants, and utility functions (2e98701)
+- fix(shell): add missing Monitor import from lucide-react (f9d56de)
+- fix(shell): restore missing MAX_TABS, TABS_STORAGE_KEY, TERMINAL_BUFFER_KEY constants (0e73408)
+- fix(shell): add missing useI18n import (3b819be)
+- fix(shell): remove stray 'impo' typo causing ReferenceError (c607943)
+- fix(terminal): improve dimensions handling and add system theme for xterm (3312005)
+- fix(shell): resolve savedTabs undefined ReferenceError in activeTab init (6cc86b7)
+- fix(terminal): improve dimension calculation and tab init reliability (1885616)
+- fix(dashboard): show MiMo quota instead of ZAI on dashboard (c8506d4)
+- feat(ai): add Xiaomi MiMo provider, ZAI as last-resort fallback (68acabd)
+- fix(terminal): use absolute positioning for content panels (b80562a)
+- feat(terminal): add Ctrl+Shift+C/V copy/paste shortcuts (c562972)
+- fix(shell): prevent Enter in AI chat from leaking to terminal (3651f62)
+- fix(terminal): improve terminal dimensions and fit timing (18e8347)
+- fix(terminal): detect shell tab visibility via MutationObserver (6596d86)
+- fix(terminal): init all tabs on load, fix excessive zoom (9fb5aa8)
+- fix(terminal): improve tab visibility checks and positioning (ab3641d)
+- fix(ui): adjust global CSS styles (5dac191)
+- fix(terminal): use display:none instead of visibility for tab hiding (e6da61f)
+- feat(ui): refactor copy state to Set and add helper functions (a994749)
+- feat(ui): add recentUnique to deduplicate recent commands in Dashboard (b394ef9)
+- feat(ui): redesign recent commands display and fix terminal visibility (fca5344)
+- fix(shell): initialize activeTabRef with activeTab and move useEffect (0a3123e)
+- fix(config): remove unused import, reorder hooks, and improve variable naming (e6447f2)
+- fix(studio): add tool results serialization and improve message handling (16c5ed6)
+- fix(shell): improve tab reference stability and command queueing (e8924be)
+- fix(shell): add debug logging for tab tracking and WebSocket state (a905f22)
+- fix(terminal): refactor WebSocket cleanup, buffer management, and disposal (183dd27)
+- fix(terminal): refactor WS cleanup, improve clear detection, fix sendToTerminal (203f57f)
+- fix: restore buffer after WebSocket init, fix clear detection, fix streaming chunks (a1046da)
+- refactor: remove locale panel, improve provider validation and terminal buffer persistence (02ee41c)
+- bump: v0.3.5 (06810be)
+- fix: display all quota models, center card content vertically (8db3bd7)
+- fix: AI terminal init, Shift+Tab nav, code block rendering, command filtering (20237c0)
+- fix(shell): set default terminal fontSize to 6px (9a218b1)
+- fix(shell): default fontSize 10px and init new tabs immediately (399b845)
+- feat(shell): add Ctrl+/- zoom and display all shortcuts in footer (436d5c6)
+- fix(deps): upgrade @xterm/xterm to 6.1.0-beta.203 for addon compatibility (5a9edc0)
+- fix(shell): enable allowProposedApi for Unicode11 addon (5bdc7a6)
+- fix(ci): add .npmrc with legacy-peer-deps for xterm addon resolution (5a0480b)
+- feat(shell): integrate Hyper-like terminal technologies (WebGL, search, unicode11, image) (80de4dd)
+- fix(shell): restore all missing imports, constants, and utility functions (de52f4e)
+- fix(shell): add missing Monitor import from lucide-react (98ff0dd)
+- fix(shell): restore missing MAX_TABS, TABS_STORAGE_KEY, TERMINAL_BUFFER_KEY constants (9a1ff6e)
+- fix(shell): add missing useI18n import (034b9ee)
+- fix(shell): remove stray 'impo' typo causing ReferenceError (c1b1fc6)
+- fix(terminal): improve dimensions handling and add system theme for xterm (50ca751)
+- fix(shell): resolve savedTabs undefined ReferenceError in activeTab init (b8aa935)
+- fix(terminal): improve dimension calculation and tab init reliability (5627ddd)
+- fix(dashboard): show MiMo quota instead of ZAI on dashboard (d278725)
+- feat(ai): add Xiaomi MiMo provider, ZAI as last-resort fallback (7d0f807)
+- fix(terminal): use absolute positioning for content panels (cbf623b)
+- feat(terminal): add Ctrl+Shift+C/V copy/paste shortcuts (b85ebb8)
+- fix(shell): prevent Enter in AI chat from leaking to terminal (7cc206d)
+- fix(terminal): improve terminal dimensions and fit timing (bf8c0fd)
+- fix(terminal): detect shell tab visibility via MutationObserver (08dc1fd)
+- fix(terminal): init all tabs on load, fix excessive zoom (13e937a)
+- fix(terminal): improve tab visibility checks and positioning (3cf701b)
+- fix(ui): adjust global CSS styles (3a09e0e)
+- fix(terminal): use display:none instead of visibility for tab hiding (47fa2e0)
+- feat(ui): refactor copy state to Set and add helper functions (401292e)
+- feat(ui): add recentUnique to deduplicate recent commands in Dashboard (199a7e4)
+- feat(ui): redesign recent commands display and fix terminal visibility (c91931f)
+- fix(shell): initialize activeTabRef with activeTab and move useEffect (cbbb224)
+- fix(config): remove unused import, reorder hooks, and improve variable naming (8d10d21)
+- fix(studio): add tool results serialization and improve message handling (e9696ef)
+- fix(shell): improve tab reference stability and command queueing (1edd4f0)
+- fix(shell): add debug logging for tab tracking and WebSocket state (92f943c)
+- fix(terminal): refactor WebSocket cleanup, buffer management, and disposal (1704b19)
+- fix(terminal): refactor WS cleanup, improve clear detection, fix sendToTerminal (40ec493)
+- fix: restore buffer after WebSocket init, fix clear detection, fix streaming chunks (233368c)
+- refactor: remove locale panel, improve provider validation and terminal buffer persistence (00118f0)
+- chore: update CHANGELOG for v0.3.4 (c39203c)
+- feat(dashboard): single-view grid with live CPU/RAM/Net graphs, API quota, processes, and sudo indicator (328e9e6)
+- feat(dashboard): add quota monitoring, process list, and command history (c81ebb4)
+- refactor(chat): deduplicate streaming code, add multi-conv, and XSS protection (b0865bc)
+- fix(studio): improve chat context, thinking tags, streaming, and tool results (0d8e1b1)
+- feat: add Cobra CLI, LSP/MCP registries, workflow engine, and enriched dashboard (485e085)
+- feat(agent): refactor AI chat with streaming, agent registry, and tool execution (61da803)
+- feat(onboarding): add minimax api key step and AI-powered editor scan (65df154)
+- fix(onboarding): require fields before advancing steps (b6147dd)
+- fix: register missing /api/config/reset and /api/starship/apply-theme routes (275a9a4)
+- fix(config): per-provider form state to avoid field cross-talk (e92a2f0)
+- fix(onboarding): auto-save on done step, keyboard nav, error feedback (1f12b8a)
+- feat(config): add system panel with reset and starship theme, add onboarding wizard (9188231)
+- chore: update CHANGELOG for v0.3.2 (28e5113)
+- chore: update CHANGELOG for v0.3.2-beta.1 (51a599f)
+- chore: update CHANGELOG for v0.3.1 (5b4a70e)
+
+### Downloads
+
+| Platform | File |
+|----------|------|
+| Linux x86_64 | [muyue-linux-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.4.0/muyue-linux-amd64.tar.gz) |
+| Linux ARM64 | [muyue-linux-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.4.0/muyue-linux-arm64.tar.gz) |
+| macOS Intel | [muyue-darwin-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.4.0/muyue-darwin-amd64.tar.gz) |
+| macOS Apple Silicon | [muyue-darwin-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.4.0/muyue-darwin-arm64.tar.gz) |
+| Windows x86_64 | [muyue-windows-amd64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.4.0/muyue-windows-amd64.zip) |
+| Windows ARM64 | [muyue-windows-arm64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.4.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.4.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.4.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.4.0/muyue-windows-amd64.zip" -OutFile "muyue.zip"
+Expand-Archive -Path "muyue.zip" -DestinationPath "."
+Move-Item muyue-windows-amd64.exe C:\Windows\muyue.exe
+```
+
+
+## v0.3.5
+
+### Changes since v0.3.5
+
+- fix(shell): set default terminal fontSize to 6px (a60435d)
+- fix(shell): default fontSize 10px and init new tabs immediately (6b0fcfb)
+- feat(shell): add Ctrl+/- zoom and display all shortcuts in footer (df46b5c)
+- fix(deps): upgrade @xterm/xterm to 6.1.0-beta.203 for addon compatibility (7240813)
+- fix(shell): enable allowProposedApi for Unicode11 addon (97bfb80)
+- fix(ci): add .npmrc with legacy-peer-deps for xterm addon resolution (3104179)
+- feat(shell): integrate Hyper-like terminal technologies (WebGL, search, unicode11, image) (e21b47a)
+- fix(shell): restore all missing imports, constants, and utility functions (2e98701)
+- fix(shell): add missing Monitor import from lucide-react (f9d56de)
+- fix(shell): restore missing MAX_TABS, TABS_STORAGE_KEY, TERMINAL_BUFFER_KEY constants (0e73408)
+- fix(shell): add missing useI18n import (3b819be)
+- fix(shell): remove stray 'impo' typo causing ReferenceError (c607943)
+- fix(terminal): improve dimensions handling and add system theme for xterm (3312005)
+- fix(shell): resolve savedTabs undefined ReferenceError in activeTab init (6cc86b7)
+- fix(terminal): improve dimension calculation and tab init reliability (1885616)
+- fix(dashboard): show MiMo quota instead of ZAI on dashboard (c8506d4)
+- feat(ai): add Xiaomi MiMo provider, ZAI as last-resort fallback (68acabd)
+- fix(terminal): use absolute positioning for content panels (b80562a)
+- feat(terminal): add Ctrl+Shift+C/V copy/paste shortcuts (c562972)
+- fix(shell): prevent Enter in AI chat from leaking to terminal (3651f62)
+- fix(terminal): improve terminal dimensions and fit timing (18e8347)
+- fix(terminal): detect shell tab visibility via MutationObserver (6596d86)
+- fix(terminal): init all tabs on load, fix excessive zoom (9fb5aa8)
+- fix(terminal): improve tab visibility checks and positioning (ab3641d)
+- fix(ui): adjust global CSS styles (5dac191)
+- fix(terminal): use display:none instead of visibility for tab hiding (e6da61f)
+- feat(ui): refactor copy state to Set and add helper functions (a994749)
+- feat(ui): add recentUnique to deduplicate recent commands in Dashboard (b394ef9)
+- feat(ui): redesign recent commands display and fix terminal visibility (fca5344)
+- fix(shell): initialize activeTabRef with activeTab and move useEffect (0a3123e)
+- fix(config): remove unused import, reorder hooks, and improve variable naming (e6447f2)
+- fix(studio): add tool results serialization and improve message handling (16c5ed6)
+- fix(shell): improve tab reference stability and command queueing (e8924be)
+- fix(shell): add debug logging for tab tracking and WebSocket state (a905f22)
+- fix(terminal): refactor WebSocket cleanup, buffer management, and disposal (183dd27)
+- fix(terminal): refactor WS cleanup, improve clear detection, fix sendToTerminal (203f57f)
+- fix: restore buffer after WebSocket init, fix clear detection, fix streaming chunks (a1046da)
+- refactor: remove locale panel, improve provider validation and terminal buffer persistence (02ee41c)
+- bump: v0.3.5 (06810be)
+- fix: display all quota models, center card content vertically (8db3bd7)
+- fix: AI terminal init, Shift+Tab nav, code block rendering, command filtering (20237c0)
+- chore: update CHANGELOG for v0.3.4 (c39203c)
+- feat(dashboard): single-view grid with live CPU/RAM/Net graphs, API quota, processes, and sudo indicator (328e9e6)
+- feat(dashboard): add quota monitoring, process list, and command history (c81ebb4)
+- refactor(chat): deduplicate streaming code, add multi-conv, and XSS protection (b0865bc)
+- fix(studio): improve chat context, thinking tags, streaming, and tool results (0d8e1b1)
+- feat: add Cobra CLI, LSP/MCP registries, workflow engine, and enriched dashboard (485e085)
+- feat(agent): refactor AI chat with streaming, agent registry, and tool execution (61da803)
+- feat(onboarding): add minimax api key step and AI-powered editor scan (65df154)
+- fix(onboarding): require fields before advancing steps (b6147dd)
+- fix: register missing /api/config/reset and /api/starship/apply-theme routes (275a9a4)
+- fix(config): per-provider form state to avoid field cross-talk (e92a2f0)
+- fix(onboarding): auto-save on done step, keyboard nav, error feedback (1f12b8a)
+- feat(config): add system panel with reset and starship theme, add onboarding wizard (9188231)
+- chore: update CHANGELOG for v0.3.2 (28e5113)
+- chore: update CHANGELOG for v0.3.2-beta.1 (51a599f)
+- chore: update CHANGELOG for v0.3.1 (5b4a70e)
+
+### Downloads
+
+| Platform | File |
+|----------|------|
+| Linux x86_64 | [muyue-linux-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.5/muyue-linux-amd64.tar.gz) |
+| Linux ARM64 | [muyue-linux-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.5/muyue-linux-arm64.tar.gz) |
+| macOS Intel | [muyue-darwin-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.5/muyue-darwin-amd64.tar.gz) |
+| macOS Apple Silicon | [muyue-darwin-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.5/muyue-darwin-arm64.tar.gz) |
+| Windows x86_64 | [muyue-windows-amd64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.5/muyue-windows-amd64.zip) |
+| Windows ARM64 | [muyue-windows-arm64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.5/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.5/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.5/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.5/muyue-windows-amd64.zip" -OutFile "muyue.zip"
+Expand-Archive -Path "muyue.zip" -DestinationPath "."
+Move-Item muyue-windows-amd64.exe C:\Windows\muyue.exe
+```
+
+
+## v0.3.4
+
+### Changes since v0.3.3
+
+- fix(ci): replace jq with python3 in release step, add debug output (7ae4017)
+- feat: AI terminal, Z.AI quota, /model change, formatting fixes, update redirects (8c540eb)
+- feat(studio): Tab focuses textarea, autocomplete commands (1074b01)
+- fix(studio): convert newlines to <br/> in AI message rendering (2da0cf9)
+- fix(config): replace hardcoded model list with free text input (9987a58)
+- feat(config): providers panel shows only MINIMAX/ZAI with model selector (2827acf)
+- feat(dashboard): show top 5 most used commands as clickable chips (afb6e77)
+- fix: tab containers height, dashboard 2-row grid, studio scroll buttons (84be226)
+- feat(shell): dedicated System Analyst AI, no code execution, analyze system (f9c4cf1)
+- fix: keep all tabs mounted, switch via CSS display instead of unmount (eda7293)
+- refactor(config): locale panel with edit/save flow like profile (b55feae)
+- feat(config): split profile into Personal Info + Preferences sections, centered (54621bd)
+- feat(studio): improve context compression UI and provider display (6bad294)
+- fix(config): locale panel show active language/keyboard, add save button (92eb783)
+- feat(config): dynamic profile panel, generic save, tabs margin fix (8005e97)
+- fix(dashboard): remove bg graphs, add scrollable lists, show used/total quota (6e76e7d)
+- feat(chat): add auto-summarization with token tracking UI (e8f6dc4)
+- feat(dashboard): add background graphs to cards and improve layout (bb03c9f)
+- feat(dashboard): single-view grid with live CPU/RAM/Net graphs, API quota, processes, and sudo indicator (79d0821)
+- feat(dashboard): add quota monitoring, process list, and command history (7682717)
+- refactor(chat): deduplicate streaming code, add multi-conv, and XSS protection (3948a4c)
+- fix(studio): improve chat context, thinking tags, streaming, and tool results (65804aa)
+- feat: add Cobra CLI, LSP/MCP registries, workflow engine, and enriched dashboard (2e50366)
+- feat(agent): refactor AI chat with streaming, agent registry, and tool execution (66b773f)
+- feat(onboarding): add minimax api key step and AI-powered editor scan (bc5c295)
+- fix(onboarding): require fields before advancing steps (e19122d)
+- fix: register missing /api/config/reset and /api/starship/apply-theme routes (8b6a7e8)
+- fix(config): per-provider form state to avoid field cross-talk (58f8cb0)
+- fix(onboarding): auto-save on done step, keyboard nav, error feedback (b52fecc)
+- feat(config): add system panel with reset and starship theme, add onboarding wizard (5bbac49)
+
+### Downloads
+
+| Platform | File |
+|----------|------|
+| Linux x86_64 | [muyue-linux-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.4/muyue-linux-amd64.tar.gz) |
+| Linux ARM64 | [muyue-linux-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.4/muyue-linux-arm64.tar.gz) |
+| macOS Intel | [muyue-darwin-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.4/muyue-darwin-amd64.tar.gz) |
+| macOS Apple Silicon | [muyue-darwin-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.4/muyue-darwin-arm64.tar.gz) |
+| Windows x86_64 | [muyue-windows-amd64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.4/muyue-windows-amd64.zip) |
+| Windows ARM64 | [muyue-windows-arm64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.4/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.4/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.4/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.4/muyue-windows-amd64.zip" -OutFile "muyue.zip"
+Expand-Archive -Path "muyue.zip" -DestinationPath "."
+Move-Item muyue-windows-amd64.exe C:\Windows\muyue.exe
+```
+
+
+## v0.3.2
+
+### Changes since v0.3.1
+
+- chore: update CHANGELOG for v0.3.2-beta.1 (51a599f)
+- fix: correct version from 3.2 to 0.3.2 (83d7a57)
+- chore: bump version to 3.2 (0fe82f6)
+- refactor(config): remove Terminal sub-tab from Configuration page (3b6cc38)
+- fix(terminal): init payload never sent due to ws.onopen being overwritten (93a22d4)
+- fix(terminal): improve shell resolution with better error handling and ws proxy support (e0e1e73)
+- feat(studio): parse AI thinking and tool launch messages in terminal panel (0496ca7)
+- fix(studio): forward AI thinking chunks to frontend instead of dropping them (b407ab8)
+- feat(studio): add tool execution and hide AI thinking tags (12df184)
+- fix(terminal): ignore invalid shell config from race condition (8af6d25)
+- feat(shell): restore AI assistant panel (4fd599a)
+- fix(terminal): restore terminal input and cursor visibility (bcba593)
+- refactor(api): split monolithic handlers.go into focused modules (04b0fff)
+
+### Downloads
+
+| Platform | File |
+|----------|------|
+| Linux x86_64 | [muyue-linux-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.2/muyue-linux-amd64.tar.gz) |
+| Linux ARM64 | [muyue-linux-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.2/muyue-linux-arm64.tar.gz) |
+| macOS Intel | [muyue-darwin-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.2/muyue-darwin-amd64.tar.gz) |
+| macOS Apple Silicon | [muyue-darwin-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.2/muyue-darwin-arm64.tar.gz) |
+| Windows x86_64 | [muyue-windows-amd64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.2/muyue-windows-amd64.zip) |
+| Windows ARM64 | [muyue-windows-arm64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.2/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.2/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.2/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.2/muyue-windows-amd64.zip" -OutFile "muyue.zip"
+Expand-Archive -Path "muyue.zip" -DestinationPath "."
+Move-Item muyue-windows-amd64.exe C:\Windows\muyue.exe
+```
+
+
+## v0.3.2-beta.1 (Beta)
+
+### Commits since v0.3.1
+
+- fix: correct version from 3.2 to 0.3.2 (83d7a57)
+
+> This is a **beta** release. Use at your own risk.
+
+## v0.3.1
+
+### Changes since v0.3.0
+
+- refactor(config): remove Terminal sub-tab from Configuration page (95bd824)
+- fix(terminal): init payload never sent due to ws.onopen being overwritten (252f178)
+- fix(terminal): improve shell resolution with better error handling and ws proxy support (7dcf505)
+- feat(studio): parse AI thinking and tool launch messages in terminal panel (8fb93fa)
+- fix(studio): forward AI thinking chunks to frontend instead of dropping them (5ec373c)
+- feat(studio): add tool execution and hide AI thinking tags (1eb5a6d)
+- fix(terminal): ignore invalid shell config from race condition (cd5ebe0)
+- feat(shell): restore AI assistant panel (2004c15)
+- fix(terminal): restore terminal input and cursor visibility (9306152)
+- refactor(api): split monolithic handlers.go into focused modules (e15a034)
+
+### Downloads
+
+| Platform | File |
+|----------|------|
+| Linux x86_64 | [muyue-linux-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.1/muyue-linux-amd64.tar.gz) |
+| Linux ARM64 | [muyue-linux-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.1/muyue-linux-arm64.tar.gz) |
+| macOS Intel | [muyue-darwin-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.1/muyue-darwin-amd64.tar.gz) |
+| macOS Apple Silicon | [muyue-darwin-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.1/muyue-darwin-arm64.tar.gz) |
+| Windows x86_64 | [muyue-windows-amd64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.1/muyue-windows-amd64.zip) |
+| Windows ARM64 | [muyue-windows-arm64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.3.1/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.1/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.1/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.1/muyue-windows-amd64.zip" -OutFile "muyue.zip"
+Expand-Archive -Path "muyue.zip" -DestinationPath "."
+Move-Item muyue-windows-amd64.exe C:\Windows\muyue.exe
+```
+
+
 ## v0.3.0
 
 ### Changes since v0.2.1

internal/agent/definitions.go

@@ -6,11 +6,18 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"sync"
 	"time"
 )
 
+var ansiRegex = regexp.MustCompile(`\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b\][^\x1b]*\x1b\\|\x1b[()][AB012]|\[\]`)
+
+func stripANSI(s string) string {
+	return ansiRegex.ReplaceAllString(s, "")
+}
+
 var (
 	sudoCache     bool
 	sudoCacheSet  bool
@@ -56,9 +63,30 @@ func NewTerminalTool() (*ToolDefinition, error) {
 			if NeedsSudoPassword() {
 				trimmed := strings.TrimSpace(p.Command)
 				lower := strings.ToLower(trimmed)
-				if strings.HasPrefix(lower, "sudo ") || strings.HasPrefix(lower, "doas ") || strings.HasPrefix(lower, "run0 ") || strings.HasPrefix(lower, "pkexec ") {
+				prefixBlocked := strings.HasPrefix(lower, "sudo ") || strings.HasPrefix(lower, "doas ") || strings.HasPrefix(lower, "run0 ") || strings.HasPrefix(lower, "pkexec ")
+				anywhereBlocked := false
+				blockedCmd := ""
+				if !prefixBlocked {
+					for _, kw := range []string{"sudo", "doas", "run0", "pkexec"} {
+						for _, pattern := range []string{" " + kw + " ", "|" + kw + " ", ";" + kw + " ", "&&" + kw + " ", "||" + kw + " ", "`" + kw + " ", "$(" + kw + " "} {
+							if strings.Contains(lower, pattern) {
+								anywhereBlocked = true
+								blockedCmd = kw
+								break
+							}
+						}
+						if anywhereBlocked {
+							break
+						}
+					}
+				}
+				if prefixBlocked || anywhereBlocked {
+					elevCmd := blockedCmd
+					if prefixBlocked {
+						elevCmd = strings.Fields(trimmed)[0]
+					}
 					return ToolResponse{
-						Content: fmt.Sprintf("BLOCKED: Command '%s' requires elevated privileges (%s). The current user is not root. Do NOT retry with sudo. Explain to the user that this command needs admin privileges and suggest an alternative, or tell them to run it manually in their terminal.", trimmed, strings.Fields(trimmed)[0]),
+						Content: fmt.Sprintf("BLOCKED: Command '%s' requires elevated privileges (%s). Passwordless sudo is not available. Do NOT retry with sudo. Explain to the user that this command needs admin privileges and suggest an alternative, or tell them to run it manually in their terminal.", trimmed, elevCmd),
 						IsError: true,
 						Meta:    map[string]string{"sudo_blocked": "true", "command": trimmed},
 					}, nil
@@ -82,6 +110,7 @@ func NewTerminalTool() (*ToolDefinition, error) {
 			output, err := cmd.CombinedOutput()
 
 			result := string(output)
+			result = stripANSI(result)
 			if len(result) > 10000 {
 				result = result[:10000] + "\n... [truncated]"
 			}
@@ -95,21 +124,35 @@ func NewTerminalTool() (*ToolDefinition, error) {
 }
 
 type CrushRunParams struct {
-	Task string `json:"task" description:"The task description for Crush to execute"`
+	Task       string `json:"task" description:"The task description for Crush to execute"`
+	Timeout    int    `json:"timeout,omitempty" description:"Maximum execution time in seconds (default 1800, max 1800)"`
+	Cwd        string `json:"cwd,omitempty" description:"Working directory in which to launch the agent (absolute path; falls back to user home)"`
+	WSLDistro  string `json:"wsl_distro,omitempty" description:"On Windows host: WSL distribution to launch the agent in (e.g. 'Ubuntu')"`
+	WSLUser    string `json:"wsl_user,omitempty" description:"On Windows host: WSL user to run the agent as"`
 }
 
 func NewCrushRunTool() (*ToolDefinition, error) {
 	return NewTool("crush_run",
-		"Delegate a complex coding task to the Crush AI agent. Crush has access to file editing, code search, bash execution, and other development tools. Use this for multi-step coding tasks like refactoring, debugging, implementing features, or code review. Returns the agent's final output.",
+		"Delegate a complex coding task to the Crush AI agent. Crush has access to file editing, code search, bash execution, and other development tools. Use this for multi-step coding tasks like refactoring, debugging, implementing features, or code review. Optionally pass cwd to run in a specific directory, or wsl_distro/wsl_user to launch inside a WSL distribution under a specific user (Windows hosts only). Returns the agent's final output.",
 		func(ctx context.Context, p CrushRunParams) (ToolResponse, error) {
 			if p.Task == "" {
 				return TextErrorResponse("task is required"), nil
 			}
 
-			ctx, cancel := context.WithTimeout(ctx, 300*time.Second)
+			timeout := time.Duration(p.Timeout) * time.Second
+			if timeout == 0 {
+				timeout = 1800 * time.Second
+			}
+			if timeout > 1800*time.Second {
+				timeout = 1800 * time.Second
+			}
+			ctx, cancel := context.WithTimeout(ctx, timeout)
 			defer cancel()
 
-			cmd := exec.CommandContext(ctx, "crush", "run", p.Task)
+			cmd, prepErr := buildAgentCommand(ctx, "crush", []string{"run", p.Task}, p.Cwd, p.WSLDistro, p.WSLUser)
+			if prepErr != nil {
+				return TextErrorResponse(prepErr.Error()), nil
+			}
 			output, err := cmd.CombinedOutput()
 
 			result := string(output)
@@ -118,7 +161,66 @@ func NewCrushRunTool() (*ToolDefinition, error) {
 			}
 
 			if err != nil {
-				return TextErrorResponse(fmt.Sprintf("Crush error: %v\n\n%s", err, result)), nil
+				errMsg := fmt.Sprintf("Crush error: %v", err)
+				if ctx.Err() == context.DeadlineExceeded {
+					errMsg = fmt.Sprintf("Crush timed out after %d seconds. Try splitting the task into smaller parts.", int(timeout.Seconds()))
+				}
+				if result != "" {
+					errMsg += "\n\n" + result
+				}
+				return TextErrorResponse(errMsg), nil
+			}
+
+			return TextResponse(result), nil
+		})
+}
+
+type ClaudeRunParams struct {
+	Task       string `json:"task" description:"The task description for Claude Code to execute"`
+	Timeout    int    `json:"timeout,omitempty" description:"Maximum execution time in seconds (default 1800, max 1800)"`
+	Cwd        string `json:"cwd,omitempty" description:"Working directory in which to launch the agent (absolute path; falls back to user home)"`
+	WSLDistro  string `json:"wsl_distro,omitempty" description:"On Windows host: WSL distribution to launch the agent in (e.g. 'Ubuntu')"`
+	WSLUser    string `json:"wsl_user,omitempty" description:"On Windows host: WSL user to run the agent as"`
+}
+
+func NewClaudeRunTool() (*ToolDefinition, error) {
+	return NewTool("claude_run",
+		"Delegate a complex coding task to the Claude Code CLI agent. Claude has access to file editing, code search, bash execution. Use for multi-step coding tasks. Same cwd/wsl_distro/wsl_user options as crush_run.",
+		func(ctx context.Context, p ClaudeRunParams) (ToolResponse, error) {
+			if p.Task == "" {
+				return TextErrorResponse("task is required"), nil
+			}
+
+			timeout := time.Duration(p.Timeout) * time.Second
+			if timeout == 0 {
+				timeout = 1800 * time.Second
+			}
+			if timeout > 1800*time.Second {
+				timeout = 1800 * time.Second
+			}
+			ctx, cancel := context.WithTimeout(ctx, timeout)
+			defer cancel()
+
+			cmd, prepErr := buildAgentCommand(ctx, "claude", []string{"-p", p.Task}, p.Cwd, p.WSLDistro, p.WSLUser)
+			if prepErr != nil {
+				return TextErrorResponse(prepErr.Error()), nil
+			}
+			output, err := cmd.CombinedOutput()
+
+			result := string(output)
+			if len(result) > 15000 {
+				result = result[:15000] + "\n... [truncated]"
+			}
+
+			if err != nil {
+				errMsg := fmt.Sprintf("Claude error: %v", err)
+				if ctx.Err() == context.DeadlineExceeded {
+					errMsg = fmt.Sprintf("Claude timed out after %d seconds. Try splitting the task into smaller parts.", int(timeout.Seconds()))
+				}
+				if result != "" {
+					errMsg += "\n\n" + result
+				}
+				return TextErrorResponse(errMsg), nil
 			}
 
 			return TextResponse(result), nil
@@ -327,6 +429,7 @@ func DefaultRegistry() *Registry {
 	tools := []*ToolDefinition{
 		must(NewTerminalTool()),
 		must(NewCrushRunTool()),
+		must(NewClaudeRunTool()),
 		must(NewReadFileTool()),
 		must(NewListFilesTool()),
 		must(NewSearchFilesTool()),

internal/agent/impl.go

@@ -26,6 +26,43 @@ func detectShell() string {
 	return "/bin/sh"
 }
 
+var validIdentifier = regexp.MustCompile(`^[a-zA-Z0-9._-]+$`)
+
+// buildAgentCommand assembles an agent execution command, optionally launching it
+// inside a WSL distribution (Windows host only) and applying a working directory.
+// On non-Windows hosts, wsl_* parameters are ignored.
+func buildAgentCommand(ctx context.Context, bin string, args []string, cwd, wslDistro, wslUser string) (*exec.Cmd, error) {
+	if wslDistro != "" && runtime.GOOS == "windows" {
+		if !validIdentifier.MatchString(wslDistro) {
+			return nil, fmt.Errorf("invalid wsl_distro: %q", wslDistro)
+		}
+		if wslUser != "" && !validIdentifier.MatchString(wslUser) {
+			return nil, fmt.Errorf("invalid wsl_user: %q", wslUser)
+		}
+		wslArgs := []string{"-d", wslDistro}
+		if wslUser != "" {
+			wslArgs = append(wslArgs, "-u", wslUser)
+		}
+		if cwd != "" {
+			wslArgs = append(wslArgs, "--cd", cwd)
+		}
+		wslArgs = append(wslArgs, "--")
+		wslArgs = append(wslArgs, bin)
+		wslArgs = append(wslArgs, args...)
+		return exec.CommandContext(ctx, "wsl", wslArgs...), nil
+	}
+
+	cmd := exec.CommandContext(ctx, bin, args...)
+	if cwd != "" {
+		dir := expandHome(cwd)
+		if info, err := os.Stat(dir); err != nil || !info.IsDir() {
+			return nil, fmt.Errorf("cwd does not exist or is not a directory: %s", cwd)
+		}
+		cmd.Dir = dir
+	}
+	return cmd, nil
+}
+
 func expandHome(path string) string {
 	if path == "" {
 		return ""

internal/agent/prompts/studio_system.md

@@ -1,6 +1,33 @@
-Tu es l'assistant IA de **Muyue Studio**, le centre de commandement de l'environnement de développement de l'utilisateur.
+Tu es l'assistant IA de **Muyue Studio**, le centre de commandement de l'environnement de développement de l'utilisateur, et tu es spécialisé dans la **construction de prompts** selon la **méthode BMAD** (Breakthrough Method for Agile AI-Driven Development — https://github.com/bmad-code-org/BMAD-METHOD).
 
-Tu es intégré dans Muyue, un gestionnaire d'environnement de développement de bureau. Ton rôle est d'aider l'utilisateur à configurer, gérer et optimiser son environnement dev.
+Tu es intégré dans Muyue, un gestionnaire d'environnement de développement de bureau. Ton rôle est double :
+1. Aider l'utilisateur à configurer, gérer et optimiser son environnement dev (avec les outils ci-dessous).
+2. Construire pour lui des prompts structurés et actionnables avant d'exécuter une tâche complexe ou de la déléguer à un agent (`crush_run`, `claude_run`).
+
+## Méthode BMAD — principes appliqués à chaque réponse
+
+BMAD organise le travail IA comme une équipe agile : chaque demande est traitée avec une persona spécifique (Analyst, PM, Architect, SM, Dev, QA) puis exécutée. Tu n'as pas besoin de jouer toutes les personas — applique simplement leurs réflexes :
+
+- **Analyst** : reformule l'objectif réel derrière la demande en 1 phrase. S'il est ambigu, choisis l'interprétation la plus probable et indique-la au début.
+- **PM** : découpe en livrables concrets (épopée → stories). Pas plus de 3-5 stories pour une demande, chaque story doit être indépendamment livrable.
+- **Architect** : pour toute story qui touche au code, identifie les fichiers concernés, les contraintes (compat, style, perf, sécurité) et les risques avant d'écrire.
+- **SM (Scrum Master)** : si tu délègues à `crush_run`/`claude_run`, fournis un prompt **autonome** : objectif, contraintes, fichiers cibles, critère d'acceptation. Pas de référence à la conversation parente — l'agent ne la voit pas.
+- **Dev** : exécute story par story. Vérifie chaque livraison avant de passer à la suivante.
+- **QA** : avant de répondre "fini", relis l'objectif initial et confirme qu'il est atteint.
+
+## Format d'un prompt BMAD délégué
+
+Quand tu construis un prompt pour `crush_run`/`claude_run`, suis ce gabarit :
+
+```
+[OBJECTIF] <une phrase, l'objectif final>
+[CONTEXTE] <fichiers/dossiers concernés, ce qui existe déjà>
+[CONTRAINTES] <ne pas faire X, préserver Y, respecter style Z>
+[LIVRABLE] <fichier(s) modifié(s), comportement attendu>
+[CRITÈRE D'ACCEPTATION] <comment savoir que c'est fini>
+```
+
+Ce gabarit est **obligatoire** pour toute délégation à un agent. Il évite que l'agent erre, suppose, ou produise du code hors-périmètre.
 
 <critical_rules>
 1. **AGIS, ne décris pas** — Si l'utilisateur demande de faire quelque chose, utilise les outils immédiatement. Ne dis pas "je pourrais faire X" — fais-le.
@@ -27,6 +54,7 @@ Muyue gère :
 |-------|-------|
 | **terminal** | Exécuter des commandes shell (builds, tests, git, etc.) |
 | **crush_run** | Déléguer une tâche complexe à Crush (édition de fichiers, refactoring, debug) — préfère cet outil pour les tâches multi-fichiers ou l'écriture de code |
+| **claude_run** | Déléguer une tâche complexe à Claude Code CLI |
 | **read_file** | Lire le contenu d'un fichier |
 | **list_files** | Lister les fichiers d'un répertoire |
 | **search_files** | Chercher des fichiers par motif (glob) |
@@ -35,6 +63,27 @@ Muyue gère :
 | **set_provider** | Configurer un fournisseur IA |
 | **manage_ssh** | Gérer les connexions SSH |
 | **web_fetch** | Récupérer le contenu d'une URL |
+| **browser_test** | Piloter un onglet de navigateur de l'utilisateur (clic, eval, lecture console) — voir `<browser_test_strategy>` ci-dessous |
+
+<browser_test_strategy>
+Quand l'utilisateur demande de **tester** une UI / une page (ses boutons, ses formulaires, son comportement), utilise `browser_test`. La page cible doit déjà être connectée via le snippet de l'onglet "Tests" — sinon, l'outil te le dira et tu demandes à l'utilisateur de coller le snippet.
+
+Boucle recommandée :
+
+1. `browser_test` action `summary` — voir l'URL, le titre et les dernières erreurs console déjà présentes.
+2. `browser_test` action `list_clickables` — récupérer la liste indexée des boutons / liens / inputs cliquables.
+3. Pour chaque cible : `browser_test` action `click` (avec `index` ou `selector`).
+4. Immédiatement après chaque clic, **regarde le `console_delta` retourné** : c'est la liste des messages console émis pendant le clic. `level: "error"` = bouton cassé.
+5. Vérifie aussi `current_url` retourné — un changement d'URL inattendu peut signaler un bug.
+6. Si l'élément ouvre un dialog ou modifie le DOM, refais `list_clickables` pour découvrir les nouveaux éléments.
+7. Pour les inputs : utilise `type` avant `click` sur le bouton de soumission.
+8. À la fin, fournis un **rapport** structuré : ✓ boutons OK / ✗ boutons cassés (avec le message d'erreur exact) / ⚠ boutons disabled ou non trouvés.
+
+Astuces :
+- Préfère cliquer **par `index`** que par sélecteur — le sélecteur change avec le DOM, l'index reste stable jusqu'au prochain `list_clickables`.
+- Entre deux actions sensibles, `wait` 200-500 ms si la page a des transitions / fetches asynchrones.
+- N'utilise jamais `eval` pour cliquer si `click` suffit.
+</browser_test_strategy>
 
 <tool_strategy>
 - **Recherche avant action** — Utilise `search_files`, `grep_content`, `read_file` avant de supposer quoi que ce soit sur l'état du système

internal/api/browsertest.go

@@ -0,0 +1,612 @@
+package api
+
+// Browser-test feature: an out-of-process page (the user's target tab)
+// connects to Muyue via WebSocket using a short-lived token, and exposes a
+// thin RPC: Studio's AI can list clickable elements, click them, evaluate JS,
+// read the recent console buffer, and observe what changes after each action.
+//
+// Threat model: an injected snippet runs in the user's chosen page only, with
+// the same origin as that page; the WS endpoint is bound to localhost and
+// gated by a 5-minute token issued by the local Muyue server.
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+	"github.com/muyue/muyue/internal/agent"
+)
+
+const (
+	browserTestTokenTTL    = 5 * time.Minute
+	browserTestCommandTTL  = 30 * time.Second
+	browserTestConsoleMax  = 200
+	browserTestSessionsMax = 16
+)
+
+// BrowserTestSession represents one connected browser tab.
+type BrowserTestSession struct {
+	ID         string
+	URL        string
+	Title      string
+	conn       *websocket.Conn
+	mu         sync.Mutex
+	console    []ConsoleEntry
+	pending    map[string]chan json.RawMessage
+	pendingMu  sync.Mutex
+	connectedAt time.Time
+	writeMu    sync.Mutex
+}
+
+// ConsoleEntry is a captured console message from the connected page.
+type ConsoleEntry struct {
+	Level   string `json:"level"` // log, info, warn, error, debug
+	Message string `json:"message"`
+	Time    string `json:"time"`
+}
+
+// BrowserTestStore manages active sessions + pending one-shot connect tokens.
+type BrowserTestStore struct {
+	mu        sync.RWMutex
+	sessions  map[string]*BrowserTestSession
+	tokens    map[string]time.Time
+	tokensMu  sync.Mutex
+}
+
+func NewBrowserTestStore() *BrowserTestStore {
+	return &BrowserTestStore{
+		sessions: map[string]*BrowserTestSession{},
+		tokens:   map[string]time.Time{},
+	}
+}
+
+// IssueToken creates a single-use token used by the snippet to authenticate.
+func (s *BrowserTestStore) IssueToken() string {
+	buf := make([]byte, 16)
+	if _, err := rand.Read(buf); err != nil {
+		return fmt.Sprintf("fallback-%d", time.Now().UnixNano())
+	}
+	tok := hex.EncodeToString(buf)
+	s.tokensMu.Lock()
+	now := time.Now()
+	for k, v := range s.tokens {
+		if now.Sub(v) > browserTestTokenTTL {
+			delete(s.tokens, k)
+		}
+	}
+	s.tokens[tok] = now
+	s.tokensMu.Unlock()
+	return tok
+}
+
+// ConsumeToken validates and removes a token in one step.
+func (s *BrowserTestStore) ConsumeToken(tok string) bool {
+	s.tokensMu.Lock()
+	defer s.tokensMu.Unlock()
+	t, ok := s.tokens[tok]
+	if !ok {
+		return false
+	}
+	delete(s.tokens, tok)
+	return time.Since(t) <= browserTestTokenTTL
+}
+
+// Register inserts a new session, evicting the oldest if at capacity.
+func (s *BrowserTestStore) Register(session *BrowserTestSession) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if len(s.sessions) >= browserTestSessionsMax {
+		var oldestID string
+		var oldest time.Time
+		for id, sess := range s.sessions {
+			if oldestID == "" || sess.connectedAt.Before(oldest) {
+				oldestID = id
+				oldest = sess.connectedAt
+			}
+		}
+		if old, ok := s.sessions[oldestID]; ok {
+			old.conn.Close()
+			delete(s.sessions, oldestID)
+		}
+	}
+	s.sessions[session.ID] = session
+}
+
+func (s *BrowserTestStore) Remove(id string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if sess, ok := s.sessions[id]; ok {
+		sess.conn.Close()
+		delete(s.sessions, id)
+	}
+}
+
+func (s *BrowserTestStore) Get(id string) *BrowserTestSession {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.sessions[id]
+}
+
+// Pick returns the requested session by ID, or the most-recently-connected
+// session if id is empty. Returns nil if no session matches.
+func (s *BrowserTestStore) Pick(id string) *BrowserTestSession {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	if id != "" {
+		return s.sessions[id]
+	}
+	var picked *BrowserTestSession
+	for _, sess := range s.sessions {
+		if picked == nil || sess.connectedAt.After(picked.connectedAt) {
+			picked = sess
+		}
+	}
+	return picked
+}
+
+func (s *BrowserTestStore) List() []map[string]interface{} {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	out := make([]map[string]interface{}, 0, len(s.sessions))
+	for _, sess := range s.sessions {
+		out = append(out, map[string]interface{}{
+			"id":           sess.ID,
+			"url":          sess.URL,
+			"title":        sess.Title,
+			"connected_at": sess.connectedAt.Format(time.RFC3339),
+		})
+	}
+	return out
+}
+
+// Send issues an RPC command to the browser session and waits up to TTL for
+// the matching reply. Returns the raw payload or an error.
+func (sess *BrowserTestSession) Send(action string, params map[string]interface{}) (json.RawMessage, error) {
+	cid := newCorrelationID()
+	ch := make(chan json.RawMessage, 1)
+	sess.pendingMu.Lock()
+	sess.pending[cid] = ch
+	sess.pendingMu.Unlock()
+	defer func() {
+		sess.pendingMu.Lock()
+		delete(sess.pending, cid)
+		sess.pendingMu.Unlock()
+	}()
+
+	cmd := map[string]interface{}{
+		"id":     cid,
+		"action": action,
+		"params": params,
+	}
+	sess.writeMu.Lock()
+	err := sess.conn.WriteJSON(cmd)
+	sess.writeMu.Unlock()
+	if err != nil {
+		return nil, fmt.Errorf("write: %w", err)
+	}
+
+	select {
+	case payload := <-ch:
+		return payload, nil
+	case <-time.After(browserTestCommandTTL):
+		return nil, fmt.Errorf("browser session did not reply within %s", browserTestCommandTTL)
+	}
+}
+
+// AppendConsole records a console line, trimming to the buffer cap.
+func (sess *BrowserTestSession) AppendConsole(level, message string) {
+	sess.mu.Lock()
+	defer sess.mu.Unlock()
+	sess.console = append(sess.console, ConsoleEntry{
+		Level:   level,
+		Message: message,
+		Time:    time.Now().Format(time.RFC3339),
+	})
+	if len(sess.console) > browserTestConsoleMax {
+		sess.console = sess.console[len(sess.console)-browserTestConsoleMax:]
+	}
+}
+
+// SnapshotConsole returns a copy of the current console buffer.
+func (sess *BrowserTestSession) SnapshotConsole() []ConsoleEntry {
+	sess.mu.Lock()
+	defer sess.mu.Unlock()
+	out := make([]ConsoleEntry, len(sess.console))
+	copy(out, sess.console)
+	return out
+}
+
+func newCorrelationID() string {
+	buf := make([]byte, 8)
+	rand.Read(buf)
+	return hex.EncodeToString(buf)
+}
+
+// HTTP handlers --------------------------------------------------------------
+
+func (s *Server) handleBrowserTestSnippet(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		writeError(w, "GET only", http.StatusMethodNotAllowed)
+		return
+	}
+	tok := s.browserTestStore.IssueToken()
+	host := r.Host
+	if host == "" {
+		host = "127.0.0.1"
+	}
+	scheme := "ws"
+	if r.TLS != nil {
+		scheme = "wss"
+	}
+	wsURL := fmt.Sprintf("%s://%s/api/ws/browser-test?token=%s", scheme, host, tok)
+	snippet := buildBrowserTestSnippet(wsURL)
+	writeJSON(w, map[string]interface{}{
+		"token":      tok,
+		"ws_url":     wsURL,
+		"snippet":    snippet,
+		"expires_in": int(browserTestTokenTTL / time.Second),
+	})
+}
+
+func (s *Server) handleBrowserTestSessions(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		writeError(w, "GET only", http.StatusMethodNotAllowed)
+		return
+	}
+	writeJSON(w, map[string]interface{}{
+		"sessions": s.browserTestStore.List(),
+	})
+}
+
+func (s *Server) handleBrowserTestConsole(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		writeError(w, "GET only", http.StatusMethodNotAllowed)
+		return
+	}
+	id := strings.TrimPrefix(r.URL.Path, "/api/test/console/")
+	sess := s.browserTestStore.Pick(id)
+	if sess == nil {
+		writeError(w, "no active browser test session", http.StatusNotFound)
+		return
+	}
+	writeJSON(w, map[string]interface{}{
+		"session_id": sess.ID,
+		"url":        sess.URL,
+		"console":    sess.SnapshotConsole(),
+	})
+}
+
+// browserTestUpgrader accepts any origin: the connection is gated by a
+// short-lived token issued to the local UI, not by Origin checking.
+var browserTestUpgrader = websocket.Upgrader{
+	CheckOrigin: func(r *http.Request) bool { return true },
+}
+
+func (s *Server) handleBrowserTestWS(w http.ResponseWriter, r *http.Request) {
+	tok := r.URL.Query().Get("token")
+	if tok == "" || !s.browserTestStore.ConsumeToken(tok) {
+		writeError(w, "invalid or expired token", http.StatusUnauthorized)
+		return
+	}
+	conn, err := browserTestUpgrader.Upgrade(w, r, nil)
+	if err != nil {
+		return
+	}
+	conn.SetReadLimit(2 << 20)
+
+	// Read the hello message: page sends {"type":"hello","url":"...","title":"..."}.
+	conn.SetReadDeadline(time.Now().Add(10 * time.Second))
+	var hello struct {
+		Type  string `json:"type"`
+		URL   string `json:"url"`
+		Title string `json:"title"`
+	}
+	if err := conn.ReadJSON(&hello); err != nil || hello.Type != "hello" {
+		conn.WriteJSON(map[string]string{"type": "error", "message": "expected hello"})
+		conn.Close()
+		return
+	}
+	conn.SetReadDeadline(time.Time{})
+
+	id := newCorrelationID()
+	sess := &BrowserTestSession{
+		ID:          id,
+		URL:         hello.URL,
+		Title:       hello.Title,
+		conn:        conn,
+		pending:     map[string]chan json.RawMessage{},
+		connectedAt: time.Now(),
+	}
+	s.browserTestStore.Register(sess)
+	defer s.browserTestStore.Remove(id)
+
+	// Acknowledge with the assigned session ID.
+	sess.writeMu.Lock()
+	conn.WriteJSON(map[string]string{"type": "registered", "session_id": id})
+	sess.writeMu.Unlock()
+
+	for {
+		_, raw, err := conn.ReadMessage()
+		if err != nil {
+			return
+		}
+		var msg struct {
+			Type  string          `json:"type"`
+			ID    string          `json:"id,omitempty"`
+			Level string          `json:"level,omitempty"`
+			Text  string          `json:"text,omitempty"`
+			URL   string          `json:"url,omitempty"`
+			Data  json.RawMessage `json:"data,omitempty"`
+		}
+		if err := json.Unmarshal(raw, &msg); err != nil {
+			continue
+		}
+		switch msg.Type {
+		case "console":
+			sess.AppendConsole(msg.Level, msg.Text)
+		case "url_change":
+			sess.mu.Lock()
+			sess.URL = msg.URL
+			sess.mu.Unlock()
+		case "reply":
+			sess.pendingMu.Lock()
+			ch, ok := sess.pending[msg.ID]
+			sess.pendingMu.Unlock()
+			if ok {
+				select {
+				case ch <- msg.Data:
+				default:
+				}
+			}
+		case "ping":
+			sess.writeMu.Lock()
+			conn.WriteJSON(map[string]string{"type": "pong"})
+			sess.writeMu.Unlock()
+		}
+	}
+}
+
+// Agent tool -----------------------------------------------------------------
+
+// BrowserTestParams is the schema exposed to the AI for the browser_test tool.
+type BrowserTestParams struct {
+	Action    string `json:"action" description:"One of: list_clickables, click, eval, console, current_url, wait, type, summary"`
+	SessionID string `json:"session_id,omitempty" description:"Browser session id (optional, defaults to most recent)"`
+	Selector  string `json:"selector,omitempty" description:"CSS selector for click/type actions"`
+	Index     int    `json:"index,omitempty" description:"Alternative to selector: index into the last list_clickables result (0-based)"`
+	Expr      string `json:"expr,omitempty" description:"JS expression to evaluate (eval action only)"`
+	Text      string `json:"text,omitempty" description:"Text to type (type action only)"`
+	WaitMs    int    `json:"wait_ms,omitempty" description:"Milliseconds to wait (wait action only, max 5000)"`
+	Tail      int    `json:"tail,omitempty" description:"Console action: how many recent lines to return (default 50, max 200)"`
+}
+
+// RegisterBrowserTestTool wires the agent tool against a session store.
+func RegisterBrowserTestTool(reg *agent.Registry, store *BrowserTestStore) error {
+	tool, err := agent.NewTool("browser_test",
+		"Drive the user's connected browser tab for end-to-end testing. Available actions: list_clickables (returns indexed clickable elements), click (by selector or index), eval (run a JS expression and return result), console (read recent console output, ideal to spot errors after a click), current_url, wait (sleep ms before next check), type (set value on an input), summary (URL+title+last console entries). Always start with list_clickables; click; then console to verify no errors.",
+		func(ctx context.Context, p BrowserTestParams) (agent.ToolResponse, error) {
+			sess := store.Pick(p.SessionID)
+			if sess == nil {
+				return agent.TextErrorResponse("no active browser session — ask the user to paste the snippet from the Tests tab in their target page"), nil
+			}
+
+			action := strings.ToLower(strings.TrimSpace(p.Action))
+			switch action {
+			case "":
+				return agent.TextErrorResponse("action is required"), nil
+			case "list_clickables", "click", "eval", "current_url", "type":
+			case "console", "summary", "wait":
+			default:
+				return agent.TextErrorResponse("unknown action: " + p.Action), nil
+			}
+
+			if action == "console" {
+				tail := p.Tail
+				if tail <= 0 {
+					tail = 50
+				}
+				if tail > browserTestConsoleMax {
+					tail = browserTestConsoleMax
+				}
+				entries := sess.SnapshotConsole()
+				if len(entries) > tail {
+					entries = entries[len(entries)-tail:]
+				}
+				out, _ := json.MarshalIndent(map[string]interface{}{
+					"session_id": sess.ID,
+					"console":    entries,
+				}, "", "  ")
+				return agent.TextResponse(string(out)), nil
+			}
+
+			if action == "summary" {
+				entries := sess.SnapshotConsole()
+				if len(entries) > 20 {
+					entries = entries[len(entries)-20:]
+				}
+				out, _ := json.MarshalIndent(map[string]interface{}{
+					"session_id":      sess.ID,
+					"url":             sess.URL,
+					"title":           sess.Title,
+					"recent_console":  entries,
+				}, "", "  ")
+				return agent.TextResponse(string(out)), nil
+			}
+
+			if action == "wait" {
+				ms := p.WaitMs
+				if ms <= 0 {
+					ms = 200
+				}
+				if ms > 5000 {
+					ms = 5000
+				}
+				select {
+				case <-ctx.Done():
+					return agent.TextErrorResponse("cancelled"), nil
+				case <-time.After(time.Duration(ms) * time.Millisecond):
+				}
+				return agent.TextResponse(fmt.Sprintf("waited %dms", ms)), nil
+			}
+
+			// Capture console snapshot length before so we can return only the delta
+			// after the action — useful so the AI can spot errors caused by the click.
+			pre := len(sess.SnapshotConsole())
+
+			params := map[string]interface{}{}
+			if p.Selector != "" {
+				params["selector"] = p.Selector
+			}
+			if p.Index > 0 || (action == "click" && p.Selector == "") {
+				params["index"] = p.Index
+			}
+			if p.Expr != "" {
+				params["expr"] = p.Expr
+			}
+			if p.Text != "" {
+				params["text"] = p.Text
+			}
+
+			payload, err := sess.Send(action, params)
+			if err != nil {
+				return agent.TextErrorResponse(err.Error()), nil
+			}
+
+			// Console delta: messages logged during this command.
+			post := sess.SnapshotConsole()
+			var delta []ConsoleEntry
+			if len(post) > pre {
+				delta = post[pre:]
+			}
+
+			result := map[string]interface{}{
+				"action":         action,
+				"reply":          json.RawMessage(payload),
+				"console_delta":  delta,
+				"current_url":    sess.URL,
+			}
+			out, _ := json.MarshalIndent(result, "", "  ")
+			return agent.TextResponse(string(out)), nil
+		})
+	if err != nil {
+		return err
+	}
+	return reg.Register(tool)
+}
+
+// Snippet generator ----------------------------------------------------------
+
+func buildBrowserTestSnippet(wsURL string) string {
+	// Note: this is the JS injected into the user's target page. It opens the
+	// WS, hooks console, and dispatches commands. Kept terse on purpose.
+	return `(function(){
+  if (window.__muyueTestRunner) { console.log('[Muyue] runner already attached'); return; }
+  var WS_URL = ` + jsString(wsURL) + `;
+  var ws = new WebSocket(WS_URL);
+  var lastList = [];
+  function send(obj){ try{ ws.send(JSON.stringify(obj)); }catch(e){} }
+  function reply(id, data){ send({type:'reply', id:id, data:data}); }
+  function safeText(el){
+    var t = (el.innerText || el.textContent || '').trim();
+    if (t.length > 80) t = t.slice(0,80)+'…';
+    return t;
+  }
+  function describe(el){
+    var sel = el.id ? '#'+el.id : el.tagName.toLowerCase();
+    if (!el.id && el.className && typeof el.className === 'string') {
+      sel += '.' + el.className.trim().split(/\s+/).slice(0,2).join('.');
+    }
+    var label = el.getAttribute('aria-label') || el.getAttribute('title') || el.getAttribute('name') || '';
+    return { tag: el.tagName.toLowerCase(), selector: sel, text: safeText(el), label: label, type: el.getAttribute('type')||'', disabled: !!el.disabled };
+  }
+  function list(){
+    var els = Array.from(document.querySelectorAll('button, a[href], input[type=submit], input[type=button], [role=button], [onclick]'));
+    lastList = els.filter(function(e){ var r=e.getBoundingClientRect(); return r.width>0 && r.height>0; });
+    return lastList.map(describe).map(function(d,i){ d.index = i; return d; });
+  }
+  function clickEl(el){
+    if (!el) return { ok:false, error:'element not found' };
+    if (el.disabled) return { ok:false, error:'element is disabled' };
+    try { el.scrollIntoView({block:'center'}); el.click(); return { ok:true }; }
+    catch(e){ return { ok:false, error:String(e) }; }
+  }
+  function dispatch(msg){
+    var p = msg.params || {};
+    switch(msg.action){
+      case 'list_clickables': return list();
+      case 'click': {
+        var el;
+        if (p.selector) el = document.querySelector(p.selector);
+        else if (typeof p.index === 'number') el = lastList[p.index];
+        return clickEl(el);
+      }
+      case 'eval': {
+        try { var r = (0,eval)(p.expr); return { ok:true, value: serialize(r) }; }
+        catch(e){ return { ok:false, error:String(e) }; }
+      }
+      case 'current_url': return { url: location.href, title: document.title };
+      case 'type': {
+        var el = p.selector ? document.querySelector(p.selector) : (lastList[p.index]);
+        if (!el) return { ok:false, error:'element not found' };
+        var proto = Object.getPrototypeOf(el);
+        var setter = Object.getOwnPropertyDescriptor(proto, 'value');
+        try { setter && setter.set ? setter.set.call(el, p.text||'') : (el.value = p.text||''); }
+        catch(e){ el.value = p.text||''; }
+        el.dispatchEvent(new Event('input', {bubbles:true}));
+        el.dispatchEvent(new Event('change', {bubbles:true}));
+        return { ok:true };
+      }
+    }
+    return { ok:false, error:'unknown action' };
+  }
+  function serialize(v){
+    if (v === undefined) return 'undefined';
+    try { return JSON.parse(JSON.stringify(v)); }
+    catch(e){ return String(v); }
+  }
+  ['log','info','warn','error','debug'].forEach(function(lvl){
+    var orig = console[lvl];
+    console[lvl] = function(){
+      try {
+        var parts = Array.from(arguments).map(function(a){
+          if (typeof a === 'string') return a;
+          try { return JSON.stringify(a); } catch(e){ return String(a); }
+        });
+        send({type:'console', level: lvl, text: parts.join(' ')});
+      } catch(e){}
+      return orig.apply(console, arguments);
+    };
+  });
+  window.addEventListener('error', function(e){
+    send({type:'console', level:'error', text:'window.onerror: '+(e.message||e.error||'unknown')});
+  });
+  window.addEventListener('unhandledrejection', function(e){
+    send({type:'console', level:'error', text:'unhandledrejection: '+String(e.reason)});
+  });
+  var lastUrl = location.href;
+  setInterval(function(){
+    if (location.href !== lastUrl){ lastUrl = location.href; send({type:'url_change', url: lastUrl}); }
+  }, 500);
+  ws.onopen = function(){ send({type:'hello', url: location.href, title: document.title}); };
+  ws.onmessage = function(ev){
+    try { var msg = JSON.parse(ev.data); }
+    catch(e){ return; }
+    if (msg.type === 'registered') { console.log('[Muyue] connected — session', msg.session_id); return; }
+    if (msg.action) reply(msg.id, dispatch(msg));
+  };
+  ws.onclose = function(){ console.log('[Muyue] runner disconnected'); window.__muyueTestRunner = null; };
+  window.__muyueTestRunner = { ws: ws, list: list };
+})();`
+}
+
+func jsString(s string) string {
+	b, _ := json.Marshal(s)
+	return string(b)
+}

internal/api/chat_engine.go

@@ -3,6 +3,7 @@ package api
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"net/http"
 
 	"github.com/muyue/muyue/internal/agent"
@@ -13,6 +14,9 @@ const (
 	MaxToolIterations = 15
 )
 
+// ToolLimiter checks if a tool call is allowed and returns a release function.
+type ToolLimiter func(toolName string) (release func(), err error)
+
 // ChatEngine handles chat interactions with tool execution.
 // This deduplicates chat logic previously repeated in handlers_chat.go and handlers_shell_chat.go.
 type ChatEngine struct {
@@ -21,6 +25,7 @@ type ChatEngine struct {
 	tools      json.RawMessage
 	onChunk    func(map[string]interface{})
 	stream    bool
+	limiter   ToolLimiter
 	TotalTokens int
 }
 
@@ -44,6 +49,11 @@ func (ce *ChatEngine) OnChunk(fn func(map[string]interface{})) {
 	ce.onChunk = fn
 }
 
+// SetLimiter sets the tool call limiter for agent concurrency control.
+func (ce *ChatEngine) SetLimiter(l ToolLimiter) {
+	ce.limiter = l
+}
+
 // RunWithTools executes the chat loop with tool calls.
 // Returns final content, tool calls, tool results, and error.
 func (ce *ChatEngine) RunWithTools(ctx context.Context, messages []orchestrator.Message) (string, []map[string]interface{}, []map[string]interface{}, error) {
@@ -76,8 +86,11 @@ func (ce *ChatEngine) RunWithTools(ctx context.Context, messages []orchestrator.
 			ce.TotalTokens += resp.Usage.TotalTokens
 		}
 
+		if len(resp.Choices) == 0 {
+			return finalContent, allToolCalls, allToolResults, fmt.Errorf("empty response from provider")
+		}
 		choice := resp.Choices[0]
-		content := cleanThinkingTags(choice.Message.Content)
+		content := orchestrator.CleanAIResponse(cleanThinkingTags(choice.Message.Content))
 
 		if content != "" {
 			if ce.onChunk != nil {
@@ -115,7 +128,40 @@ func (ce *ChatEngine) RunWithTools(ctx context.Context, messages []orchestrator.
 				Arguments: json.RawMessage(tc.Function.Arguments),
 			}
 
+			var release func()
+			if ce.limiter != nil {
+				rel, limitErr := ce.limiter(tc.Function.Name)
+				if limitErr != nil {
+					limResultData := map[string]interface{}{
+						"tool_call_id": tc.ID,
+						"content":     limitErr.Error(),
+						"is_error":    true,
+					}
+					allToolResults = append(allToolResults, map[string]interface{}{
+						"tool_call_id": tc.ID,
+						"name":        tc.Function.Name,
+						"args":        tc.Function.Arguments,
+						"result":      limitErr.Error(),
+						"is_error":    true,
+					})
+					if ce.onChunk != nil {
+						ce.onChunk(map[string]interface{}{"tool_result": limResultData})
+					}
+					messages = append(messages, orchestrator.Message{
+						Role:       "tool",
+						Content:    orchestrator.TextContent(limitErr.Error()),
+						ToolCallID: tc.ID,
+						Name:       tc.Function.Name,
+					})
+					continue
+				}
+				release = rel
+			}
+
 			result, execErr := ce.registry.Execute(ctx, call)
+			if release != nil {
+				release()
+			}
 			if execErr != nil {
 				result = agent.ToolResponse{
 					Content: execErr.Error(),
@@ -178,8 +224,11 @@ func (ce *ChatEngine) RunNonStream(ctx context.Context, messages []orchestrator.
 			ce.TotalTokens += resp.Usage.TotalTokens
 		}
 
+		if len(resp.Choices) == 0 {
+			return finalContent, fmt.Errorf("empty response from provider")
+		}
 		choice := resp.Choices[0]
-		content := cleanThinkingTags(choice.Message.Content)
+		content := orchestrator.CleanAIResponse(cleanThinkingTags(choice.Message.Content))
 
 		if content != "" {
 			finalContent = content
@@ -203,7 +252,25 @@ func (ce *ChatEngine) RunNonStream(ctx context.Context, messages []orchestrator.
 				Arguments: json.RawMessage(tc.Function.Arguments),
 			}
 
+			var release func()
+			if ce.limiter != nil {
+				rel, limitErr := ce.limiter(tc.Function.Name)
+				if limitErr != nil {
+					messages = append(messages, orchestrator.Message{
+						Role:       "tool",
+						Content:    orchestrator.TextContent(limitErr.Error()),
+						ToolCallID: tc.ID,
+						Name:       tc.Function.Name,
+					})
+					continue
+				}
+				release = rel
+			}
+
 			result, execErr := ce.registry.Execute(ctx, call)
+			if release != nil {
+				release()
+			}
 			if execErr != nil {
 				result = agent.ToolResponse{
 					Content: execErr.Error(),
@@ -258,6 +325,5 @@ func SetupSSEHeaders(w http.ResponseWriter) {
 	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)
 }

internal/api/conversation.go

@@ -17,27 +17,66 @@ const contextWindowTokens = 150000
 const summarizeRatio = 0.80
 const charsPerToken = 4
 
+func extractDisplayContent(role, content string) string {
+	if role != "assistant" {
+		return content
+	}
+	var parsed struct {
+		Content     string `json:"content"`
+		ToolCalls   []struct {
+			Name string `json:"name"`
+			Args string `json:"args"`
+		} `json:"tool_calls"`
+		ToolResults []struct {
+			Name   string `json:"name"`
+			Result string `json:"result"`
+		} `json:"tool_results"`
+	}
+	if err := json.Unmarshal([]byte(content), &parsed); err != nil {
+		return content
+	}
+	var sb strings.Builder
+	if parsed.Content != "" {
+		sb.WriteString(parsed.Content)
+	}
+	for _, tc := range parsed.ToolCalls {
+		sb.WriteString("\n[")
+		sb.WriteString(tc.Name)
+		sb.WriteString("] ")
+		sb.WriteString(tc.Args)
+	}
+	for _, tr := range parsed.ToolResults {
+		sb.WriteString("\n[result")
+		if tr.Name != "" {
+			sb.WriteString(":")
+			sb.WriteString(tr.Name)
+		}
+		sb.WriteString("] ")
+		sb.WriteString(tr.Result)
+	}
+	return sb.String()
+}
+
 type FeedMessage struct {
-	ID      string   `json:"id"`
+	ID         string   `json:"id"`
-	Role    string   `json:"role"`
+	Role       string   `json:"role"`
-	Content string   `json:"content"`
+	Content    string   `json:"content"`
-	Time    string   `json:"time"`
+	Time       string   `json:"time"`
-	Images  []string `json:"images,omitempty"`
+	Images     []string `json:"images,omitempty"`
+	Summarized bool     `json:"summarized,omitempty"`
 }
 
 type Conversation struct {
-	Messages   []FeedMessage `json:"messages"`
+	Messages  []FeedMessage `json:"messages"`
-	Summary    string        `json:"summary,omitempty"`
+	Summary   string        `json:"summary,omitempty"`
-	RealTokens int           `json:"real_tokens,omitempty"`
+	CreatedAt string        `json:"created_at"`
-	CreatedAt  string        `json:"created_at"`
+	UpdatedAt string        `json:"updated_at"`
-	UpdatedAt  string        `json:"updated_at"`
 }
 
 type ConversationStore struct {
-	mu         sync.RWMutex
+	mu   sync.RWMutex
-	path       string
+	path string
-	conv       *Conversation
+	conv *Conversation
-	realTokens int
 }
 
 type TokenCount struct {
@@ -87,7 +126,6 @@ func (cs *ConversationStore) load() {
 		conv.Messages = []FeedMessage{}
 	}
 	cs.conv = &conv
-	cs.realTokens = conv.RealTokens
 }
 
 func (cs *ConversationStore) save() error {
@@ -157,10 +195,8 @@ func (cs *ConversationStore) Clear() {
 
 	cs.conv.Messages = []FeedMessage{}
 	cs.conv.Summary = ""
-	cs.conv.RealTokens = 0
 	cs.conv.CreatedAt = time.Now().Format(time.RFC3339)
 	cs.conv.UpdatedAt = time.Now().Format(time.RFC3339)
-	cs.realTokens = 0
 	cs.save()
 
 	go cleanupImages(imageIDs)
@@ -173,34 +209,22 @@ func (cs *ConversationStore) SetSummary(summary string) {
 	cs.save()
 }
 
-func (cs *ConversationStore) TrimOld(keepCount int) {
+func (cs *ConversationStore) MarkSummarized(upToIndex int) {
 	cs.mu.Lock()
 	defer cs.mu.Unlock()
-	if len(cs.conv.Messages) <= keepCount {
+	if upToIndex <= 0 || upToIndex >= len(cs.conv.Messages) {
 		return
 	}
-	cs.conv.Messages = cs.conv.Messages[len(cs.conv.Messages)-keepCount:]
+	for i := 0; i < upToIndex; i++ {
+		cs.conv.Messages[i].Summarized = true
+	}
 	cs.save()
 }
 
 func (cs *ConversationStore) ApproxTokenCount() int {
-	if cs.realTokens > 0 {
-		return cs.realTokens
-	}
 	return cs.ApproxTokenCountDetailed().total
 }
 
-// AddRealTokens accumulates actual token counts from the API response.
-func (cs *ConversationStore) AddRealTokens(tokens int) {
-	if tokens <= 0 {
-		return
-	}
-	cs.mu.Lock()
-	cs.realTokens += tokens
-	cs.conv.RealTokens = cs.realTokens
-	cs.mu.Unlock()
-}
-
 func (cs *ConversationStore) ApproxTokenCountDetailed() TokenCount {
 	cs.mu.RLock()
 	defer cs.mu.RUnlock()
@@ -210,7 +234,10 @@ func (cs *ConversationStore) ApproxTokenCountDetailed() TokenCount {
 	}
 
 	for _, m := range cs.conv.Messages {
-		count := utf8.RuneCountInString(m.Content) / charsPerToken
+		if m.Role == "system" || m.Summarized {
+			continue
+		}
+		count := utf8.RuneCountInString(extractDisplayContent(m.Role, m.Content)) / charsPerToken
 		result.byMessage += count
 		result.byRole[m.Role] += count
 	}

internal/api/conversation_multi.go

@@ -222,9 +222,9 @@ func (cs *ConversationStoreMulti) Add(role, content string) FeedMessage {
 		Time:    time.Now().Format(time.RFC3339),
 	}
 	conv.Messages = append(conv.Messages, msg)
-	
+
-	go cs.saveCurrent() // Fire and forget
+	cs.saveCurrent()
-	
+
 	return msg
 }
 

internal/api/handlers_ai_task.go

@@ -0,0 +1,172 @@
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/muyue/muyue/internal/orchestrator"
+)
+
+func (s *Server) handleAITask(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var body struct {
+		Task string `json:"task"`
+		Tool string `json:"tool,omitempty"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if body.Task == "" {
+		writeError(w, "task is required", http.StatusBadRequest)
+		return
+	}
+
+	orb, err := orchestrator.New(s.config)
+	if err != nil {
+		writeError(w, "AI not available: "+err.Error(), http.StatusServiceUnavailable)
+		return
+	}
+
+	orb.SetSystemPrompt(buildAITaskSystemPrompt())
+	orb.SetTools(s.shellAgentToolsJSON)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second)
+	defer cancel()
+
+	messages := []orchestrator.Message{
+		{Role: "user", Content: orchestrator.TextContent(buildAITaskPrompt(body.Task, body.Tool))},
+	}
+
+	engine := NewChatEngine(orb, s.shellAgentRegistry, s.shellAgentToolsJSON)
+	finalContent, err := engine.RunNonStream(ctx, messages)
+	if err != nil {
+		writeError(w, "AI task failed: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	s.consumption.Record(engine.ProviderName(), engine.TotalTokens)
+
+	parsed := parseAIJSONResponse(finalContent)
+
+	writeJSON(w, map[string]interface{}{
+		"status":  "ok",
+		"raw":     finalContent,
+		"result":  parsed,
+		"tokens":  engine.TotalTokens,
+	})
+}
+
+func buildAITaskSystemPrompt() string {
+	return fmt.Sprintf(`You are a system administration assistant. You have access to a terminal tool to run commands on the host system.
+
+IMPORTANT RULES:
+- You MUST respond ONLY with valid JSON. No markdown, no code fences, no extra text.
+- Always run the actual commands needed to complete the task.
+- Be thorough: check versions, verify installations, compare with latest releases.
+
+OS: %s/%s
+Date: %s
+`, runtime.GOOS, runtime.GOARCH, time.Now().Format("2006-01-02"))
+}
+
+func buildAITaskPrompt(task, tool string) string {
+	switch task {
+	case "check_tools":
+		return `Check the following tools on this system. For each tool, determine:
+1. Is it installed? Run "which <tool>" or "<tool> --version"
+2. If installed, what is the current version?
+3. What is the latest available version? Check GitHub releases API or official sources.
+
+Tools to check: crush, claude, git, node, npm, pnpm, python3, pip3, uv, go, docker, gh, starship, npx
+
+Run the commands needed, then respond with ONLY this JSON structure (no markdown fences):
+{
+  "tools": [
+    {"name": "tool_name", "installed": true/false, "version": "x.y.z", "latest": "a.b.c", "needs_update": true/false, "category": "ai|runtime|vcs|devops|prompt"}
+  ]
+}`
+
+	case "install_tool":
+		return fmt.Sprintf(`Install the tool "%s" on this system.
+
+Steps:
+1. Check if it's already installed: run "which %s" and "%s --version"
+2. If not installed, determine the best installation method for this OS
+3. Run the installation command
+4. Verify the installation succeeded
+
+Respond with ONLY this JSON (no markdown fences):
+{
+  "tool": "%s",
+  "installed": true/false,
+  "version": "installed version or empty",
+  "message": "what was done",
+  "error": "error message or empty"
+}`, tool, tool, tool, tool)
+
+	case "update_tool":
+		return fmt.Sprintf(`Update the tool "%s" to its latest version on this system.
+
+Steps:
+1. Check current version: run "%s --version"
+2. Find the latest version available
+3. Run the update/upgrade command
+4. Verify the new version
+
+Respond with ONLY this JSON (no markdown fences):
+{
+  "tool": "%s",
+  "previous_version": "old version",
+  "version": "new version",
+  "updated": true/false,
+  "message": "what was done",
+  "error": "error message or empty"
+}`, tool, tool, tool)
+
+	default:
+		return task
+	}
+}
+
+func parseAIJSONResponse(content string) interface{} {
+	cleaned := content
+
+	if idx := strings.Index(cleaned, "```json"); idx != -1 {
+		cleaned = cleaned[idx+7:]
+		if end := strings.Index(cleaned, "```"); end != -1 {
+			cleaned = cleaned[:end]
+		}
+	} else if idx := strings.Index(cleaned, "```"); idx != -1 {
+		cleaned = cleaned[idx+3:]
+		if end := strings.Index(cleaned, "```"); end != -1 {
+			cleaned = cleaned[:end]
+		}
+	}
+
+	cleaned = strings.TrimSpace(cleaned)
+
+	jsonStart := strings.Index(cleaned, "{")
+	jsonEnd := strings.LastIndex(cleaned, "}")
+	if jsonStart != -1 && jsonEnd > jsonStart {
+		cleaned = cleaned[jsonStart : jsonEnd+1]
+	}
+
+	var result interface{}
+	if err := json.Unmarshal([]byte(cleaned), &result); err != nil {
+		return map[string]interface{}{
+			"raw":   content,
+			"error": "failed to parse AI response as JSON",
+		}
+	}
+	return result
+}

internal/api/handlers_chat.go

@@ -6,16 +6,17 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log"
 	"net/http"
 	"os"
 	"path/filepath"
 	"regexp"
 	"strings"
 	"time"
+	"unicode/utf8"
 
 	"github.com/muyue/muyue/internal/agent"
 	"github.com/muyue/muyue/internal/orchestrator"
+	"github.com/muyue/muyue/internal/platform"
 )
 
 var thinkingTagRegex = regexp.MustCompile(`(?s)<[Tt]hink[^>]*>.*?</[Tt]hink>`)
@@ -63,15 +64,13 @@ func (s *Server) describeImages(images []ImageAttachment) []string {
 		}
 	}
 	if apiKey == "" {
-		log.Printf("[vlm] no API key found for image description")
 		return nil
 	}
 
 	descriptions := make([]string, 0, len(images))
-	for i, img := range images {
+	for _, img := range images {
 		desc, err := s.callVLM(apiKey, img)
 		if err != nil {
-			log.Printf("[vlm] image %d (%s) failed: %v", i+1, img.Filename, err)
 			descriptions = append(descriptions, fmt.Sprintf("(description unavailable: %v)", err))
 		} else {
 			descriptions = append(descriptions, desc)
@@ -133,10 +132,12 @@ func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
 		writeError(w, "POST only", http.StatusMethodNotAllowed)
 		return
 	}
+	r.Body = http.MaxBytesReader(w, r.Body, 50*1024*1024)
 	var body struct {
-		Message    string           `json:"message"`
+		Message            string            `json:"message"`
-		Stream     bool             `json:"stream"`
+		Stream             bool              `json:"stream"`
-		Images     []ImageAttachment `json:"images"`
+		Images             []ImageAttachment `json:"images"`
+		AdvancedReflection bool              `json:"advanced_reflection"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 		writeError(w, err.Error(), http.StatusBadRequest)
@@ -162,7 +163,7 @@ func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
 
 			id, err := saveImage(body.Images[i].Data, body.Images[i].Filename, body.Images[i].MimeType)
 			if err != nil {
-				log.Printf("[images] failed to save %s: %v", body.Images[i].Filename, err)
+				_ = err
 			} else {
 				imageIDs = append(imageIDs, id)
 			}
@@ -196,7 +197,12 @@ func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
 	}
 	var studioPrompt strings.Builder
 	studioPrompt.WriteString(agent.StudioSystemPrompt())
-	studioPrompt.WriteString(fmt.Sprintf("\nDate: %s\nHeure: %s\n", time.Now().Format("02/01/2006"), time.Now().Format("15:04:05")))
+	sysInfo := platform.Detect()
+	osName := sysInfo.OSName
+	if osName == "" {
+		osName = string(sysInfo.OS)
+	}
+	studioPrompt.WriteString(fmt.Sprintf("\nDate: %s\nHeure: %s\nSystème: %s\n", time.Now().Format("02/01/2006"), time.Now().Format("15:04:05"), osName))
 	canSudo := !agent.NeedsSudoPassword()
 	studioPrompt.WriteString(fmt.Sprintf("Root: %t\n", !canSudo))
 	if !canSudo {
@@ -207,6 +213,12 @@ func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
 	orb.SetSystemPrompt(studioPrompt.String())
 	orb.SetTools(s.agentToolsJSON)
 
+	if body.AdvancedReflection {
+		if report, ok := s.runReflectionReport(enrichedMessage); ok {
+			enrichedMessage = enrichedMessage + "\n\n[RAPPORT PRÉALABLE — produit par un autre modèle, à valider]\n" + report + "\n[/RAPPORT PRÉALABLE]"
+		}
+	}
+
 	if body.Stream {
 		s.handleStreamChat(w, orb, enrichedMessage)
 	} else {
@@ -226,6 +238,7 @@ func (s *Server) handleStreamChat(w http.ResponseWriter, orb *orchestrator.Orche
 	messages := s.buildContextMessages(userMessage)
 
 	engine := NewChatEngine(orb, s.agentRegistry, s.agentToolsJSON)
+	engine.SetLimiter(s.AcquireAgentSlot)
 	engine.OnChunk(func(data map[string]interface{}) {
 		if data == nil {
 			return
@@ -253,7 +266,6 @@ func (s *Server) handleStreamChat(w http.ResponseWriter, orb *orchestrator.Orche
 		storeContent = string(storeJSON)
 	}
 	s.convStore.Add("assistant", storeContent)
-	s.convStore.AddRealTokens(engine.TotalTokens)
 
 	s.consumption.Record(engine.ProviderName(), engine.TotalTokens)
 
@@ -265,6 +277,7 @@ func (s *Server) handleNonStreamChat(w http.ResponseWriter, orb *orchestrator.Or
 	messages := s.buildContextMessages(userMessage)
 
 	engine := NewChatEngine(orb, s.agentRegistry, s.agentToolsJSON)
+	engine.SetLimiter(s.AcquireAgentSlot)
 	finalContent, err := engine.RunNonStream(ctx, messages)
 	if err != nil {
 		writeError(w, err.Error(), http.StatusInternalServerError)
@@ -272,7 +285,6 @@ func (s *Server) handleNonStreamChat(w http.ResponseWriter, orb *orchestrator.Or
 	}
 
 	s.convStore.Add("assistant", finalContent)
-	s.convStore.AddRealTokens(engine.TotalTokens)
 
 	s.consumption.Record(engine.ProviderName(), engine.TotalTokens)
 
@@ -283,19 +295,75 @@ func cleanThinkingTags(content string) string {
 	return strings.TrimSpace(thinkingTagRegex.ReplaceAllString(content, ""))
 }
 
-const contextWindowMessages = 20
+// runReflectionReport runs the inactive AI provider on the user message to
+// produce a preliminary analysis report that the active provider will then
+// use as additional context. Returns ("", false) if no inactive provider is
+// configured or on error — the caller falls back to a normal chat flow.
+func (s *Server) runReflectionReport(userMessage string) (string, bool) {
+	orb, err := orchestrator.NewForInactiveProvider(s.config)
+	if err != nil {
+		return "", false
+	}
+	orb.SetSystemPrompt("Tu es un analyste. Pour la question ci-dessous, produis un rapport bref (max 15 lignes) qui : (1) reformule l'objectif de l'utilisateur, (2) liste les points à clarifier ou les risques, (3) suggère une approche structurée. Pas de code, pas d'action — uniquement de l'analyse.")
+	resp, err := orb.SendNoTools(userMessage)
+	if err != nil {
+		return "", false
+	}
+	return strings.TrimSpace(resp), true
+}
 
 func (s *Server) buildContextMessages(userMessage string) []orchestrator.Message {
 	history := s.convStore.Get()
-	start := 0
+
-	if len(history) > contextWindowMessages {
+	sysPromptTokens := utf8.RuneCountInString(agent.StudioSystemPrompt())/charsPerToken + 50
-		start = len(history) - contextWindowMessages
+	toolsTokens := utf8.RuneCountInString(string(s.agentToolsJSON)) / charsPerToken
+	responseMargin := 4000
+	userMsgTokens := utf8.RuneCountInString(userMessage) / charsPerToken
+
+	overhead := sysPromptTokens + toolsTokens + responseMargin + userMsgTokens
+	available := contextWindowTokens - overhead
+	if available < 1000 {
+		available = 1000
 	}
 
-	messages := make([]orchestrator.Message, 0, len(history[start:])+1)
+	included := 0
+	tokensUsed := 0
+	for i := len(history) - 1; i >= 0; i-- {
+		if history[i].Summarized {
+			break
+		}
+		displayContent := extractDisplayContent(history[i].Role, history[i].Content)
+		msgTokens := utf8.RuneCountInString(displayContent) / charsPerToken
+		if msgTokens == 0 {
+			msgTokens = 1
+		}
+		if tokensUsed+msgTokens > available {
+			break
+		}
+		tokensUsed += msgTokens
+		included++
+	}
+
+	start := len(history) - included
+	if start < 0 {
+		start = 0
+	}
+
+	hasSummarized := false
+	for i := 0; i < start; i++ {
+		if history[i].Summarized {
+			hasSummarized = true
+			break
+		}
+	}
+	if start > 0 {
+		_ = start
+	}
+
+	messages := make([]orchestrator.Message, 0, included+2)
 
 	summary := s.convStore.GetSummary()
-	if summary != "" {
+	if summary != "" && (start > 0 || hasSummarized) {
 		messages = append(messages, orchestrator.Message{
 			Role:    "system",
 			Content: orchestrator.TextContent("Résumé de la conversation précédente:\n" + summary),
@@ -303,27 +371,13 @@ func (s *Server) buildContextMessages(userMessage string) []orchestrator.Message
 	}
 
 	for _, m := range history[start:] {
-		content := m.Content
+		if m.Role == "system" {
-		if m.Role == "assistant" {
-			var parsed struct {
-				Content   string `json:"content"`
-				ToolCalls []struct {
-					ToolCallID string `json:"tool_call_id"`
-					Name       string `json:"name"`
-					Args       string `json:"args"`
-				} `json:"tool_calls"`
-			}
-			if err := json.Unmarshal([]byte(content), &parsed); err == nil && parsed.Content != "" {
-				content = parsed.Content
-			}
-		}
-		role := m.Role
-		if role == "system" {
 			continue
 		}
+		displayContent := extractDisplayContent(m.Role, m.Content)
 		messages = append(messages, orchestrator.Message{
-			Role:    role,
+			Role:    m.Role,
-			Content: orchestrator.TextContent(content),
+			Content: orchestrator.TextContent(displayContent),
 		})
 	}
 
@@ -364,8 +418,7 @@ func (s *Server) autoSummarize() {
 	}
 
 	s.convStore.SetSummary(result)
-	s.convStore.TrimOld(len(messages) - half)
+	s.convStore.MarkSummarized(half)
-	s.convStore.Add("system", "[Conversation résumée automatiquement]")
 }
 
 func (s *Server) handleChatHistory(w http.ResponseWriter, r *http.Request) {

internal/api/handlers_config.go

@@ -60,10 +60,17 @@ func (s *Server) handleSaveProfile(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	var currentMap map[string]interface{}
-	json.Unmarshal(currentJSON, &currentMap)
+	if err := json.Unmarshal(currentJSON, &currentMap); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
 
 	var updates map[string]interface{}
-	body, _ := io.ReadAll(r.Body)
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
 	if err := json.Unmarshal(body, &updates); err != nil {
 		writeError(w, err.Error(), http.StatusBadRequest)
 		return
@@ -71,8 +78,15 @@ func (s *Server) handleSaveProfile(w http.ResponseWriter, r *http.Request) {
 
 	deepMerge(currentMap, updates)
 
-	mergedJSON, _ := json.Marshal(currentMap)
+	mergedJSON, err := json.Marshal(currentMap)
-	json.Unmarshal(mergedJSON, &s.config.Profile)
+	if err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	if err := json.Unmarshal(mergedJSON, &s.config.Profile); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
 
 	if err := config.Save(s.config); err != nil {
 		writeError(w, err.Error(), http.StatusInternalServerError)
@@ -122,7 +136,7 @@ func (s *Server) handleSaveProvider(w http.ResponseWriter, r *http.Request) {
 	found := false
 	for i := range s.config.AI.Providers {
 		if s.config.AI.Providers[i].Name == body.Name {
-			if body.APIKey != "" {
+			if body.APIKey != "" && body.APIKey != "***" {
 				s.config.AI.Providers[i].APIKey = body.APIKey
 			}
 			if body.Model != "" {
@@ -173,6 +187,14 @@ func (s *Server) handleValidateProvider(w http.ResponseWriter, r *http.Request)
 		writeError(w, "api_key required", http.StatusBadRequest)
 		return
 	}
+	if body.APIKey == "***" {
+		for _, p := range s.config.AI.Providers {
+			if p.Name == body.Name {
+				body.APIKey = p.APIKey
+				break
+			}
+		}
+	}
 
 	baseURL := body.BaseURL
 	if baseURL == "" {
@@ -266,7 +288,7 @@ func (s *Server) handleSaveTerminalSettings(w http.ResponseWriter, r *http.Reque
 		writeError(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	if body.FontSize > 0 {
+	if body.FontSize > 0 && body.FontSize <= 72 {
 		s.config.Terminal.FontSize = body.FontSize
 	}
 	if body.FontFamily != "" {
@@ -335,30 +357,25 @@ func (s *Server) handleApplyStarshipTheme(w http.ResponseWriter, r *http.Request
 		body.Theme = s.config.Terminal.PromptTheme
 	}
 
-	cfgDir, err := config.ConfigDir()
+	themeFile := ApplyStarshipTheme(body.Theme)
-	if err != nil {
+
-		writeError(w, err.Error(), http.StatusInternalServerError)
+	s.config.Terminal.PromptTheme = body.Theme
-		return
+	config.Save(s.config)
-	}
+
+	writeJSON(w, map[string]interface{}{"status": "ok", "config": themeFile})
+}
+
+func ApplyStarshipTheme(theme string) string {
+	cfgDir, _ := config.ConfigDir()
 	starshipDir := filepath.Join(cfgDir, "starship")
-	if err := os.MkdirAll(starshipDir, 0755); err != nil {
+	os.MkdirAll(starshipDir, 0755)
-		writeError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
 	themeFile := filepath.Join(starshipDir, "starship.toml")
 
-	themeContent := getStarshipThemeConfig(body.Theme)
+	themeContent := getStarshipThemeConfig(theme)
-	if err := os.WriteFile(themeFile, []byte(themeContent), 0644); err != nil {
+	os.WriteFile(themeFile, []byte(themeContent), 0644)
-		writeError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
 
 	home, _ := os.UserHomeDir()
-	shellRCs := []string{
+	for _, rc := range []string{filepath.Join(home, ".bashrc"), filepath.Join(home, ".zshrc")} {
-		filepath.Join(home, ".bashrc"),
-		filepath.Join(home, ".zshrc"),
-	}
-	for _, rc := range shellRCs {
 		if _, err := os.Stat(rc); err != nil {
 			continue
 		}
@@ -375,10 +392,7 @@ func (s *Server) handleApplyStarshipTheme(w http.ResponseWriter, r *http.Request
 		f.Close()
 	}
 
-	s.config.Terminal.PromptTheme = body.Theme
+	return themeFile
-	config.Save(s.config)
-
-	writeJSON(w, map[string]interface{}{"status": "ok", "config": themeFile})
 }
 
 func getStarshipThemeConfig(theme string) string {

internal/api/handlers_info.go

@@ -80,8 +80,23 @@ func (s *Server) handleProviders(w http.ResponseWriter, r *http.Request) {
 		writeError(w, "no config", http.StatusNotFound)
 		return
 	}
+	masked := make([]map[string]interface{}, 0, len(s.config.AI.Providers))
+	for _, p := range s.config.AI.Providers {
+		entry := map[string]interface{}{
+			"name":     p.Name,
+			"model":    p.Model,
+			"base_url": p.BaseURL,
+			"active":   p.Active,
+		}
+		if p.APIKey != "" {
+			entry["api_key"] = "***"
+		} else {
+			entry["api_key"] = ""
+		}
+		masked = append(masked, entry)
+	}
 	writeJSON(w, map[string]interface{}{
-		"providers": s.config.AI.Providers,
+		"providers": masked,
 	})
 }
 
@@ -91,6 +106,9 @@ func (s *Server) handleSkills(w http.ResponseWriter, r *http.Request) {
 		writeError(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
+	for i := range list {
+		list[i].Deployed = skills.IsDeployed(list[i].Name)
+	}
 	writeJSON(w, map[string]interface{}{
 		"skills": list,
 		"count":  len(list),
@@ -200,9 +218,20 @@ func (s *Server) handleLSPAutoInstall(w http.ResponseWriter, r *http.Request) {
 		json.NewDecoder(r.Body).Decode(&body)
 	}
 
+	home, _ := os.UserHomeDir()
 	if body.ProjectDir == "" {
-		home, _ := os.UserHomeDir()
 		body.ProjectDir = home
+	} else {
+		abs, err := filepath.Abs(body.ProjectDir)
+		if err != nil {
+			writeError(w, "invalid project_dir", http.StatusBadRequest)
+			return
+		}
+		body.ProjectDir = abs
+		if home != "" && !strings.HasPrefix(abs, home+string(filepath.Separator)) && abs != home {
+			writeError(w, "project_dir must be within user home", http.StatusBadRequest)
+			return
+		}
 	}
 
 	results, err := lsp.AutoInstallForProject(body.ProjectDir)

internal/api/handlers_missing.go

@@ -226,6 +226,29 @@ func (s *Server) handleSkillsDeploy(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, map[string]string{"status": "all deployed"})
 }
 
+func (s *Server) handleSkillsUndeploy(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		writeError(w, "POST only", http.StatusMethodNotAllowed)
+		return
+	}
+	var body struct {
+		Name string `json:"name"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+		writeError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if body.Name == "" {
+		writeError(w, "name is required", http.StatusBadRequest)
+		return
+	}
+	if err := skills.Undeploy(body.Name); err != nil {
+		writeError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, map[string]string{"status": "undeployed", "skill": body.Name})
+}
+
 func (s *Server) handleSSHConnections(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "GET" {
 		writeError(w, "GET only", http.StatusMethodNotAllowed)

internal/api/handlers_shell_chat.go

@@ -10,6 +10,7 @@ import (
 	"runtime"
 	"strings"
 	"time"
+	"unicode/utf8"
 
 	"github.com/muyue/muyue/internal/agent"
 	"github.com/muyue/muyue/internal/orchestrator"
@@ -106,6 +107,7 @@ func (s *Server) handleShellChatStream(w http.ResponseWriter, orb *orchestrator.
 	messages := s.buildShellContextMessages()
 
 	engine := NewChatEngine(orb, s.shellAgentRegistry, s.shellAgentToolsJSON)
+	engine.SetLimiter(s.AcquireAgentSlot)
 	engine.OnChunk(func(data map[string]interface{}) {
 		if data == nil {
 			return
@@ -133,7 +135,6 @@ func (s *Server) handleShellChatStream(w http.ResponseWriter, orb *orchestrator.
 		storeContent = string(storeJSON)
 	}
 	s.shellConvStore.Add("assistant", storeContent)
-	s.shellConvStore.AddRealTokens(engine.TotalTokens)
 
 	s.consumption.Record(engine.ProviderName(), engine.TotalTokens)
 
@@ -148,6 +149,7 @@ func (s *Server) handleShellChatNonStream(w http.ResponseWriter, orb *orchestrat
 	messages := s.buildShellContextMessages()
 
 	engine := NewChatEngine(orb, s.shellAgentRegistry, s.shellAgentToolsJSON)
+	engine.SetLimiter(s.AcquireAgentSlot)
 	finalContent, err := engine.RunNonStream(ctx, messages)
 	if err != nil {
 		writeError(w, err.Error(), http.StatusInternalServerError)
@@ -155,7 +157,6 @@ func (s *Server) handleShellChatNonStream(w http.ResponseWriter, orb *orchestrat
 	}
 
 	s.shellConvStore.Add("assistant", finalContent)
-	s.shellConvStore.AddRealTokens(engine.TotalTokens)
 
 	s.consumption.Record(engine.ProviderName(), engine.TotalTokens)
 
@@ -167,36 +168,55 @@ func (s *Server) handleShellChatNonStream(w http.ResponseWriter, orb *orchestrat
 
 func (s *Server) buildShellContextMessages() []orchestrator.Message {
 	history := s.shellConvStore.Get()
-	start := 0
+
-	const shellContextWindow = 20
+	sysTokens := utf8.RuneCountInString(shellSystemPromptBase) / charsPerToken
-	if len(history) > shellContextWindow {
+	if analysis := LoadSystemAnalysis(); analysis != "" {
-		start = len(history) - shellContextWindow
+		sysTokens += utf8.RuneCountInString(analysis) / charsPerToken
+	}
+	sysTokens += 100
+	toolsTokens := utf8.RuneCountInString(string(s.shellAgentToolsJSON)) / charsPerToken
+	responseMargin := 4000
+
+	overhead := sysTokens + toolsTokens + responseMargin
+	available := shellMaxTokens - overhead
+	if available < 1000 {
+		available = 1000
 	}
 
-	messages := make([]orchestrator.Message, 0, len(history[start:]))
+	included := 0
+	tokensUsed := 0
+	for i := len(history) - 1; i >= 0; i-- {
+		displayContent := extractDisplayContent(history[i].Role, history[i].Content)
+		msgTokens := utf8.RuneCountInString(displayContent) / charsPerToken
+		if msgTokens == 0 {
+			msgTokens = 1
+		}
+		if tokensUsed+msgTokens > available {
+			break
+		}
+		tokensUsed += msgTokens
+		included++
+	}
+
+	start := len(history) - included
+	if start < 0 {
+		start = 0
+	}
+
+	if start > 0 {
+		_ = start
+	}
+
+	messages := make([]orchestrator.Message, 0, included)
 
 	for _, m := range history[start:] {
-		content := m.Content
+		if m.Role == "system" {
-		if m.Role == "assistant" {
-			var parsed struct {
-				Content   string `json:"content"`
-				ToolCalls []struct {
-					ToolCallID string `json:"tool_call_id"`
-					Name       string `json:"name"`
-					Args       string `json:"args"`
-				} `json:"tool_calls"`
-			}
-			if err := json.Unmarshal([]byte(content), &parsed); err == nil && parsed.Content != "" {
-				content = parsed.Content
-			}
-		}
-		role := m.Role
-		if role == "system" {
 			continue
 		}
+		displayContent := extractDisplayContent(m.Role, m.Content)
 		messages = append(messages, orchestrator.Message{
-			Role:    role,
+			Role:    m.Role,
-			Content: orchestrator.TextContent(content),
+			Content: orchestrator.TextContent(displayContent),
 		})
 	}
 

internal/api/handlers_workflow.go

@@ -144,7 +144,7 @@ func (s *Server) handleWorkflowPlan(w http.ResponseWriter, r *http.Request) {
 		engine, _ = workflow.NewEngine(s.agentRegistry)
 	}
 
-	wf := engine.Create("Plan: "+body.Goal[:min(len(body.Goal), 30)], body.Goal, "plan_execute", steps)
+	wf := engine.Create("Plan: "+truncateString(body.Goal, 30), body.Goal, "plan_execute", steps)
 	writeJSON(w, wf)
 }
 
@@ -188,7 +188,6 @@ func (s *Server) handleWorkflowExecuteStream(w http.ResponseWriter, engine *work
 	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)
 
@@ -250,9 +249,10 @@ func (s *Server) handleWorkflowApprove(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, map[string]string{"status": "approved"})
 }
 
-func min(a, b int) int {
+func truncateString(s string, max int) string {
-	if a < b {
+	runes := []rune(s)
-		return a
+	if len(runes) <= max {
+		return s
 	}
-	return b
+	return string(runes[:max])
 }

internal/api/image_cache.go

@@ -3,7 +3,6 @@ package api
 import (
 	"encoding/base64"
 	"fmt"
-	"log"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -38,6 +37,9 @@ func saveImage(dataURI, filename, mimeType string) (string, error) {
 	if err != nil {
 		return "", fmt.Errorf("base64 decode: %w", err)
 	}
+	if len(decoded) > 10*1024*1024 {
+		return "", fmt.Errorf("image too large (max 10MB)")
+	}
 
 	id := fmt.Sprintf("%d-%d", time.Now().UnixMilli(), atomic.AddUint64(&imageCounter, 1))
 	ext := ".png"
@@ -64,7 +66,7 @@ func cleanupImages(ids []string) {
 	for _, id := range ids {
 		p := imagePath(id)
 		if err := os.Remove(p); err != nil && !os.IsNotExist(err) {
-			log.Printf("[images] failed to delete %s: %v", id, err)
+			_ = err
 		}
 	}
 }

internal/api/server.go

@@ -2,12 +2,15 @@ package api
 
 import (
 	"encoding/json"
-	"log"
+	"fmt"
 	"net/http"
+	"os/exec"
 	"strings"
+	"sync/atomic"
 
 	"github.com/muyue/muyue/internal/agent"
 	"github.com/muyue/muyue/internal/config"
+	"github.com/muyue/muyue/internal/installer"
 	"github.com/muyue/muyue/internal/scanner"
 	"github.com/muyue/muyue/internal/workflow"
 )
@@ -24,6 +27,9 @@ type Server struct {
 	shellAgentRegistry  *agent.Registry
 	shellAgentToolsJSON json.RawMessage
 	workflowEngine      *workflow.Engine
+	browserTestStore    *BrowserTestStore
+	activeCrushAgents   atomic.Int32
+	activeClaudeAgents  atomic.Int32
 }
 
 func NewServer(cfg *config.MuyueConfig) *Server {
@@ -43,7 +49,7 @@ func NewServer(cfg *config.MuyueConfig) *Server {
 		}
 		// Save initial config to establish the file for first-time usage
 		if err := config.Save(defaultCfg); err != nil {
-			log.Printf("config: initial save failed: %v", err)
+			_ = err
 		}
 		cfg = defaultCfg
 	}
@@ -53,6 +59,11 @@ func NewServer(cfg *config.MuyueConfig) *Server {
 	s.shellConvStore = NewShellConvStore()
 	s.consumption = newConsumptionStore()
 	s.agentRegistry = agent.DefaultRegistry()
+	s.browserTestStore = NewBrowserTestStore()
+	if err := RegisterBrowserTestTool(s.agentRegistry, s.browserTestStore); err != nil {
+		// Tool registration only fails for duplicate names — non-fatal
+		_ = err
+	}
 	tools := s.agentRegistry.OpenAITools()
 	toolsJSON, _ := json.Marshal(tools)
 	s.agentToolsJSON = json.RawMessage(toolsJSON)
@@ -65,6 +76,7 @@ func NewServer(cfg *config.MuyueConfig) *Server {
 	s.shellAgentToolsJSON = json.RawMessage(shellToolsJSON)
 
 	s.workflowEngine, _ = workflow.NewEngine(s.agentRegistry)
+	s.initStarship()
 	s.routes()
 	return s
 }
@@ -120,6 +132,7 @@ func (s *Server) routes() {
 	s.mux.HandleFunc("/api/conversations/", s.handleDeleteConversation)
 	s.mux.HandleFunc("/api/lsp/install", s.handleLSPInstall)
 	s.mux.HandleFunc("/api/skills/deploy", s.handleSkillsDeploy)
+	s.mux.HandleFunc("/api/skills/undeploy", s.handleSkillsUndeploy)
 	s.mux.HandleFunc("/api/ssh/connections", s.handleSSHConnections)
 	s.mux.HandleFunc("/api/ssh/test", s.handleSSHTest)
 
@@ -133,11 +146,17 @@ func (s *Server) routes() {
 	s.mux.HandleFunc("/api/skills/export", s.handleSkillExport)
 	s.mux.HandleFunc("/api/skills/import", s.handleSkillImport)
 	s.mux.HandleFunc("/api/dashboard/status", s.handleDashboardStatus)
+	s.mux.HandleFunc("/api/ai/task", s.handleAITask)
 	s.mux.HandleFunc("/api/providers/quota", s.handleProvidersQuota)
 	s.mux.HandleFunc("/api/providers/consumption", s.handleProvidersConsumption)
 	s.mux.HandleFunc("/api/recent-commands", s.handleRecentCommands)
 	s.mux.HandleFunc("/api/running-processes", s.handleRunningProcesses)
 	s.mux.HandleFunc("/api/system/metrics", s.handleSystemMetrics)
+
+	s.mux.HandleFunc("/api/test/snippet", s.handleBrowserTestSnippet)
+	s.mux.HandleFunc("/api/test/sessions", s.handleBrowserTestSessions)
+	s.mux.HandleFunc("/api/test/console/", s.handleBrowserTestConsole)
+	s.mux.HandleFunc("/api/ws/browser-test", s.handleBrowserTestWS)
 }
 
 func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
@@ -146,8 +165,11 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	w.Header().Set("Content-Type", "application/json")
-	w.Header().Set("Access-Control-Allow-Origin", "*")
+	if origin := r.Header.Get("Origin"); isAllowedOrigin(origin) {
-	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Origin", origin)
+		w.Header().Set("Vary", "Origin")
+	}
+	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
 	w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
 	if r.Method == "OPTIONS" {
 		w.WriteHeader(http.StatusOK)
@@ -155,3 +177,53 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 	s.mux.ServeHTTP(w, r)
 }
+
+func isAllowedOrigin(origin string) bool {
+	if origin == "" {
+		return false
+	}
+	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
+	}
+	return false
+}
+
+const maxCrushAgents = 2
+const maxClaudeAgents = 2
+
+func (s *Server) AcquireAgentSlot(toolName string) (release func(), err error) {
+	var counter *atomic.Int32
+	var max int32
+	switch toolName {
+	case "crush_run":
+		counter = &s.activeCrushAgents
+		max = maxCrushAgents
+	case "claude_run":
+		counter = &s.activeClaudeAgents
+		max = maxClaudeAgents
+	default:
+		return func() {}, nil
+	}
+	current := counter.Add(1)
+	if current > max {
+		counter.Add(-1)
+		return nil, fmt.Errorf("Limite de %d agents %s atteinte", max, toolName)
+	}
+	return func() { counter.Add(-1) }, nil
+}
+
+func (s *Server) initStarship() {
+	if _, err := exec.LookPath("starship"); err != nil {
+		inst := installer.New(s.config)
+		if result := inst.InstallTool("starship"); !result.Success {
+			return
+		}
+	}
+	ApplyStarshipTheme(s.config.Terminal.PromptTheme)
+}

internal/api/shell_conversation.go

@@ -79,10 +79,9 @@ type ShellMessage struct {
 }
 
 type ShellConvStore struct {
-	mu         sync.RWMutex
+	mu   sync.RWMutex
-	path       string
+	path string
-	msgs       []ShellMessage
+	msgs []ShellMessage
-	realTokens int
 }
 
 func NewShellConvStore() *ShellConvStore {
@@ -140,19 +139,18 @@ func (s *ShellConvStore) Clear() {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.msgs = []ShellMessage{}
-	s.realTokens = 0
 	s.save()
 }
 
 func (s *ShellConvStore) ApproxTokens() int {
-	if s.realTokens > 0 {
-		return s.realTokens
-	}
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	total := 0
 	for _, m := range s.msgs {
-		total += utf8.RuneCountInString(m.Content) / shellCharsPerToken
+		if m.Role == "system" {
+			continue
+		}
+		total += utf8.RuneCountInString(extractDisplayContent(m.Role, m.Content)) / shellCharsPerToken
 	}
 	total += utf8.RuneCountInString(shellSystemPromptBase) / shellCharsPerToken
 	if analysis := LoadSystemAnalysis(); analysis != "" {
@@ -161,16 +159,6 @@ func (s *ShellConvStore) ApproxTokens() int {
 	return total
 }
 
-// AddRealTokens accumulates actual token counts from the API response.
-func (s *ShellConvStore) AddRealTokens(tokens int) {
-	if tokens <= 0 {
-		return
-	}
-	s.mu.Lock()
-	s.realTokens += tokens
-	s.mu.Unlock()
-}
-
 func (s *ShellConvStore) AtLimit() bool {
 	return s.ApproxTokens() >= shellMaxTokens
 }

internal/api/terminal.go

@@ -3,11 +3,11 @@ package api
 import (
 	"encoding/json"
 	"fmt"
-	"log"
 	"net/http"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strings"
 	"sync"
@@ -48,7 +48,6 @@ type wsMessage struct {
 func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 	conn, err := upgrader.Upgrade(w, r, nil)
 	if err != nil {
-		log.Printf("ws upgrade: %v", err)
 		return
 	}
 	defer conn.Close()
@@ -56,26 +55,23 @@ 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
 
 	if initMsg.Type == "ssh" && initMsg.Data != "" {
 		var sshConf struct {
-			Host    string `json:"host"`
+			Host     string `json:"host"`
-			Port    int    `json:"port"`
+			Port     int    `json:"port"`
-			User    string `json:"user"`
+			User     string `json:"user"`
-			KeyPath string `json:"key_path"`
+			KeyPath  string `json:"key_path"`
+			Password string `json:"password"`
 		}
 		if err := json.Unmarshal([]byte(initMsg.Data), &sshConf); err != nil {
 			conn.WriteJSON(wsMessage{Type: "error", Data: "invalid ssh config"})
@@ -98,54 +94,71 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 		}
 		sshArgs = append(sshArgs, fmt.Sprintf("%s@%s", sshConf.User, sshConf.Host))
 
-		cmd = exec.Command("ssh", sshArgs...)
+		if sshConf.Password != "" {
+			sshpassPath, err := exec.LookPath("sshpass")
+			if err == nil {
+				args := append([]string{"-e"}, "ssh")
+				args = append(args, sshArgs...)
+				cmd = exec.Command(sshpassPath, args...)
+				cmd.Env = append(os.Environ(), "SSHPASS="+sshConf.Password)
+			} else {
+				cmd = exec.Command("ssh", sshArgs...)
+			}
+		} else {
+			cmd = exec.Command("ssh", sshArgs...)
+		}
 	} else {
 		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 shell == "" {
-			log.Printf("terminal: no shell detected, falling back to /bin/sh")
 			shell = "/bin/sh"
 		}
 
-		if path, err := exec.LookPath(shell); err == nil {
+		// Support "wsl -d <distro>" shell strings sent from the UI quick-access.
-			shell = path
+		if extra, ok := parseWSLShell(shell); ok {
-			log.Printf("terminal: resolved shell path=%q", shell)
+			wslPath, err := exec.LookPath("wsl")
-		}
+			if err != nil {
+				conn.WriteJSON(wsMessage{Type: "error", Data: "wsl not found on this host"})
+				return
+			}
+			cmd = exec.Command(wslPath, extra...)
+		} else {
+			if path, err := exec.LookPath(shell); err == nil {
+				shell = path
+			}
 
-		if _, err := os.Stat(shell); err != nil {
+			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)})
-			conn.WriteJSON(wsMessage{Type: "error", Data: fmt.Sprintf("shell not found: %s (resolved from: %q)", shell, initMsg.Data)})
+				return
-			return
+			}
-		}
 
-		shellName := filepath.Base(shell)
+			shellName := filepath.Base(shell)
-		switch shellName {
+			switch shellName {
-		case "wsl":
+			case "wsl":
-			cmd = exec.Command(shell, "--shell-type", "login")
+				cmd = exec.Command(shell, "--shell-type", "login")
-		case "powershell", "pwsh":
+			case "powershell", "pwsh":
-			cmd = exec.Command(shell, "-NoLogo", "-NoProfile")
+				cmd = exec.Command(shell, "-NoLogo", "-NoProfile")
-		case "fish":
+			case "fish":
-			cmd = exec.Command(shell, "--login")
+				cmd = exec.Command(shell, "--login")
-		default:
+			default:
-			cmd = exec.Command(shell)
+				cmd = exec.Command(shell)
+			}
 		}
 	}
 
-	cmd.Env = append(os.Environ(), "TERM=xterm-256color")
+	if cmd.Env == nil {
+		cmd.Env = os.Environ()
+	}
+	cmd.Env = append(cmd.Env, "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("terminal: pty start failed: %v", err)
 		conn.WriteJSON(wsMessage{Type: "error", Data: err.Error()})
 		return
 	}
-	log.Printf("terminal: pty started successfully")
 
 	var once sync.Once
 	cleanup := func() {
@@ -211,8 +224,15 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 
 func (s *Server) handleTerminalSessions(w http.ResponseWriter, r *http.Request) {
 	if r.Method == "GET" {
+		masked := make([]config.SSHConnection, len(s.config.Terminal.SSH))
+		for i, c := range s.config.Terminal.SSH {
+			masked[i] = c
+			if masked[i].Password != "" {
+				masked[i].Password = "***"
+			}
+		}
 		writeJSON(w, map[string]interface{}{
-			"ssh":    s.config.Terminal.SSH,
+			"ssh":    masked,
 			"system": detectSystemTerminals(),
 		})
 		return
@@ -222,11 +242,12 @@ func (s *Server) handleTerminalSessions(w http.ResponseWriter, r *http.Request)
 		return
 	}
 	var body struct {
-		Name    string `json:"name"`
+		Name     string `json:"name"`
-		Host    string `json:"host"`
+		Host     string `json:"host"`
-		Port    int    `json:"port"`
+		Port     int    `json:"port"`
-		User    string `json:"user"`
+		User     string `json:"user"`
-		KeyPath string `json:"key_path"`
+		KeyPath  string `json:"key_path"`
+		Password string `json:"password"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 		writeError(w, err.Error(), http.StatusBadRequest)
@@ -240,12 +261,36 @@ func (s *Server) handleTerminalSessions(w http.ResponseWriter, r *http.Request)
 		body.Port = 22
 	}
 
+	for i, c := range s.config.Terminal.SSH {
+		if c.Name == body.Name {
+			password := body.Password
+			if password == "***" {
+				password = c.Password
+			}
+			s.config.Terminal.SSH[i] = config.SSHConnection{
+				Name:     body.Name,
+				Host:     body.Host,
+				Port:     body.Port,
+				User:     body.User,
+				KeyPath:  body.KeyPath,
+				Password: password,
+			}
+			if err := config.Save(s.config); err != nil {
+				writeError(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+			writeJSON(w, map[string]string{"status": "ok"})
+			return
+		}
+	}
+
 	conn := config.SSHConnection{
-		Name:    body.Name,
+		Name:     body.Name,
-		Host:    body.Host,
+		Host:     body.Host,
-		Port:    body.Port,
+		Port:     body.Port,
-		User:    body.User,
+		User:     body.User,
-		KeyPath: body.KeyPath,
+		KeyPath:  body.KeyPath,
+		Password: body.Password,
 	}
 	if s.config.Terminal.SSH == nil {
 		s.config.Terminal.SSH = []config.SSHConnection{}
@@ -297,6 +342,87 @@ func detectShell() string {
 	return "/bin/sh"
 }
 
+// listWSLDistros returns the list of installed WSL distribution names.
+// Windows hosts only — returns nil on other platforms or if WSL is unavailable.
+func listWSLDistros() []string {
+	if runtime.GOOS != "windows" {
+		return nil
+	}
+	out, err := exec.Command("wsl", "--list", "--quiet").Output()
+	if err != nil {
+		return nil
+	}
+	// `wsl --list --quiet` outputs UTF-16LE on Windows. Strip BOM and decode best-effort.
+	raw := stripUTF16ToASCII(out)
+	var distros []string
+	seen := make(map[string]bool)
+	for _, line := range strings.Split(raw, "\n") {
+		name := strings.TrimSpace(line)
+		if name == "" || seen[name] {
+			continue
+		}
+		// Skip default-marker arrows or annotations.
+		name = strings.TrimSpace(strings.TrimPrefix(name, "*"))
+		if name == "" || !validWSLName.MatchString(name) {
+			continue
+		}
+		seen[name] = true
+		distros = append(distros, name)
+	}
+	return distros
+}
+
+var validWSLName = regexp.MustCompile(`^[a-zA-Z0-9._-]+$`)
+
+// parseWSLShell recognises strings of the form "wsl -d <distro>" (and optionally
+// "-u <user>") emitted by the Shell tab quick-access menu, returning the args
+// to pass to the wsl binary. Returns ok=false otherwise.
+func parseWSLShell(shell string) ([]string, bool) {
+	parts := strings.Fields(shell)
+	if len(parts) < 3 || parts[0] != "wsl" {
+		return nil, false
+	}
+	args := []string{}
+	i := 1
+	for i < len(parts) {
+		switch parts[i] {
+		case "-d", "--distribution":
+			if i+1 >= len(parts) || !validWSLName.MatchString(parts[i+1]) {
+				return nil, false
+			}
+			args = append(args, "-d", parts[i+1])
+			i += 2
+		case "-u", "--user":
+			if i+1 >= len(parts) || !validWSLName.MatchString(parts[i+1]) {
+				return nil, false
+			}
+			args = append(args, "-u", parts[i+1])
+			i += 2
+		default:
+			return nil, false
+		}
+	}
+	if len(args) == 0 {
+		return nil, false
+	}
+	return args, true
+}
+
+func stripUTF16ToASCII(b []byte) string {
+	// Best-effort: keep only printable bytes (drop high bytes from UTF-16LE pairs).
+	var out []byte
+	for i := 0; i < len(b); i++ {
+		c := b[i]
+		if c == 0 {
+			continue
+		}
+		if c >= 32 && c < 127 || c == '\n' || c == '\r' || c == '\t' {
+			out = append(out, c)
+		}
+	}
+	return string(out)
+}
+
 func detectSystemTerminals() []map[string]string {
 	var terminals []map[string]string
 
@@ -309,10 +435,17 @@ func detectSystemTerminals() []map[string]string {
 	if runtime.GOOS == "windows" {
 		if _, err := exec.LookPath("wsl"); err == nil {
 			terminals = append(terminals, map[string]string{
-				"type": "local",
+				"type":  "local",
-				"name": "WSL",
+				"name":  "WSL (default)",
 				"shell": "wsl",
 			})
+			for _, distro := range listWSLDistros() {
+				terminals = append(terminals, map[string]string{
+					"type":  "local",
+					"name":  "WSL: " + distro,
+					"shell": "wsl -d " + distro,
+				})
+			}
 		}
 		if _, err := exec.LookPath("powershell"); err == nil {
 			terminals = append(terminals, map[string]string{

internal/config/config.go

@@ -2,7 +2,6 @@ package config
 
 import (
 	"fmt"
-	"log"
 	"os"
 	"path/filepath"
 
@@ -162,7 +161,7 @@ func ConfigDir() (string, error) {
 	if _, err := os.Stat(legacyDir); err == nil {
 		if _, err := os.Stat(dir); err != nil {
 			if err := os.Rename(legacyDir, dir); err != nil {
-				log.Printf("config migration: rename %s to %s: %v", legacyDir, dir, err)
+				_ = err
 			}
 		}
 	}

internal/orchestrator/orchestrator.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"log"
 	"net/http"
 	"regexp"
 	"strings"
@@ -17,6 +16,14 @@ import (
 )
 
 var thinkRegex = regexp.MustCompile(`(?s)<[Tt]hink[^>]*>.*?</[Tt]hink>`)
+var providerToolBlockRegex = regexp.MustCompile(`(?s)<[a-zA-Z][a-zA-Z0-9]*:tool_call[^>]*>.*?</[a-zA-Z][a-zA-Z0-9]*:tool_call>`)
+var providerTagRegex = regexp.MustCompile(`(?s)</?[a-zA-Z][a-zA-Z0-9]*:[a-zA-Z_]+[^>]*>`)
+var xmlToolTagRegex = regexp.MustCompile(`(?s)</?(invoke|parameter|tool_call|tool_result)[^>]*>`)
+var bracketToolCallRegex = regexp.MustCompile(`(?m)^\[(?:terminal|shell|bash|command|execute)\]\s*\{[^}]*\}\s*$`)
+
+var streamBlockStartRegex = regexp.MustCompile(`<[a-zA-Z][a-zA-Z0-9]*:tool_call`)
+var streamXmlStartRegex = regexp.MustCompile(`<(?:invoke|parameter|tool_call|tool_result)[\s>]`)
+var streamBracketStartRegex = regexp.MustCompile(`\[(?:terminal|shell|bash|command|execute)\]\s*\{`)
 
 const maxHistorySize = 100
 
@@ -135,6 +142,37 @@ func New(cfg *config.MuyueConfig) (*Orchestrator, error) {
 	}, nil
 }
 
+// NewForProvider builds an orchestrator using a specific (non-active) provider,
+// for the Advanced Reflection feature where the inactive provider produces a
+// preliminary report before the active provider answers. Excludes the currently
+// active provider from selection — picks the first other configured provider
+// with a non-empty API key.
+func NewForInactiveProvider(cfg *config.MuyueConfig) (*Orchestrator, error) {
+	var activeName string
+	for _, p := range cfg.AI.Providers {
+		if p.Active {
+			activeName = p.Name
+			break
+		}
+	}
+	for i := range cfg.AI.Providers {
+		p := &cfg.AI.Providers[i]
+		if p.Name == activeName {
+			continue
+		}
+		if p.APIKey == "" {
+			continue
+		}
+		return &Orchestrator{
+			config:   cfg,
+			provider: p,
+			client:   sharedHTTPClient,
+			history:  []Message{},
+		}, nil
+	}
+	return nil, fmt.Errorf("no inactive provider with API key configured")
+}
+
 func (o *Orchestrator) SetSystemPrompt(prompt string) {
 	o.systemPrompt = prompt
 }
@@ -167,6 +205,33 @@ func (o *Orchestrator) GetHistory() []Message {
 	return out
 }
 
+// SendNoTools issues a one-shot, history-less request to this orchestrator's
+// provider. Used by the Advanced Reflection feature so the inactive provider
+// can produce a preliminary report without contaminating the active
+// orchestrator's history or invoking tools.
+func (o *Orchestrator) SendNoTools(userMessage string) (string, error) {
+	messages := make([]Message, 0, 2)
+	if o.systemPrompt != "" {
+		messages = append(messages, Message{Role: "system", Content: TextContent(o.systemPrompt)})
+	}
+	messages = append(messages, Message{Role: "user", Content: TextContent(userMessage)})
+
+	reqBody := ChatRequest{
+		Model:    o.provider.Model,
+		Messages: messages,
+		Stream:   false,
+	}
+
+	chatResp, _, err := o.sendWithFallback(reqBody, "")
+	if err != nil {
+		return "", err
+	}
+	if len(chatResp.Choices) == 0 {
+		return "", fmt.Errorf("empty response from provider")
+	}
+	return CleanAIResponse(chatResp.Choices[0].Message.Content), nil
+}
+
 func (o *Orchestrator) Send(userMessage string) (string, error) {
 	o.histMu.Lock()
 	o.history = append(o.history, Message{
@@ -197,7 +262,7 @@ func (o *Orchestrator) Send(userMessage string) (string, error) {
 		return "", err
 	}
 
-	content := cleanAIResponse(chatResp.Choices[0].Message.Content)
+	content := CleanAIResponse(chatResp.Choices[0].Message.Content)
 	o.histMu.Lock()
 	o.history = append(o.history, Message{
 		Role:    "assistant",
@@ -297,7 +362,7 @@ func (o *Orchestrator) SendStream(userMessage string, onChunk func(string)) (str
 		return fullContent.String(), fmt.Errorf("read stream: %w", err)
 	}
 
-	content := cleanAIResponse(fullContent.String())
+	content := CleanAIResponse(fullContent.String())
 	o.histMu.Lock()
 	o.history = append(o.history, Message{
 		Role:    "assistant",
@@ -388,6 +453,7 @@ func (o *Orchestrator) SendWithToolsStream(messages []Message, onChunk ChunkCall
 	var fullContent strings.Builder
 	var accumulatedToolCalls []ToolCallMsg
 	var totalTokens int
+	var insideToolBlock bool
 
 	scanner := bufio.NewScanner(resp.Body)
 	scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
@@ -411,7 +477,10 @@ func (o *Orchestrator) SendWithToolsStream(messages []Message, onChunk ChunkCall
 			chunk := chatResp.Choices[0].Delta.Content
 			if chunk != "" {
 				fullContent.WriteString(chunk)
-				onChunk(chunk, nil)
+				cleanedChunk := CleanStreamChunk(chunk, &insideToolBlock)
+				if cleanedChunk != "" {
+					onChunk(cleanedChunk, nil)
+				}
 			}
 
 			// Handle delta tool calls
@@ -463,15 +532,19 @@ func (o *Orchestrator) SendWithToolsStream(messages []Message, onChunk ChunkCall
 		}{},
 	}
 
-	finalContent := cleanAIResponse(fullContent.String())
+	finalContent := CleanAIResponse(fullContent.String())
 	finalResp.Choices[0].Message.Content = finalContent
 	finalResp.Choices[0].Message.ToolCalls = accumulatedToolCalls
 
 	return finalResp, nil
 }
 
-func cleanAIResponse(content string) string {
+func CleanAIResponse(content string) string {
 	content = thinkRegex.ReplaceAllString(content, "")
+	content = providerToolBlockRegex.ReplaceAllString(content, "")
+	content = providerTagRegex.ReplaceAllString(content, "")
+	content = xmlToolTagRegex.ReplaceAllString(content, "")
+	content = bracketToolCallRegex.ReplaceAllString(content, "")
 	lines := strings.Split(content, "\n")
 	var clean []string
 	inBlock := false
@@ -494,6 +567,35 @@ func cleanAIResponse(content string) string {
 	return result
 }
 
+// CleanStreamChunk applies lightweight cleaning to individual streaming chunks.
+// It tracks state via a bool pointer to suppress content inside tool-call blocks.
+func CleanStreamChunk(chunk string, insideBlock *bool) string {
+	if *insideBlock {
+		// Check for closing tag
+		if strings.Contains(chunk, ":tool_call>") {
+			*insideBlock = false
+		}
+		return ""
+	}
+
+	// Check for opening tool_call block
+	if streamBlockStartRegex.MatchString(chunk) {
+		*insideBlock = true
+		// If closing tag also in same chunk, emit nothing
+		if strings.Contains(chunk, ":tool_call>") {
+			*insideBlock = false
+		}
+		return ""
+	}
+
+	// Clean individual tags and bracket calls
+	cleaned := providerTagRegex.ReplaceAllString(chunk, "")
+	cleaned = xmlToolTagRegex.ReplaceAllString(cleaned, "")
+	cleaned = bracketToolCallRegex.ReplaceAllString(cleaned, "")
+
+	return cleaned
+}
+
 func getProviderBaseURL(name string) string {
 	switch name {
 	case "minimax":
@@ -616,6 +718,5 @@ func (o *Orchestrator) sendWithFallback(reqBody ChatRequest, baseURLOverride str
 		return &chatResp, prov.Name, nil
 	}
 
-	log.Printf("[orchestrator] fallback from %v to next provider", triedProviders)
 	return nil, "", lastErr
 }

internal/orchestrator/orchestrator_test.go

@@ -65,11 +65,11 @@ func TestCleanAIResponse(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := cleanAIResponse(tt.input)
+			result := CleanAIResponse(tt.input)
 			result = strings.TrimSpace(result)
 			expected := strings.TrimSpace(tt.expected)
 			if result != expected {
-				t.Errorf("cleanAIResponse(%q) = %q, want %q", tt.input, result, expected)
+				t.Errorf("CleanAIResponse(%q) = %q, want %q", tt.input, result, expected)
 			}
 		})
 	}
@@ -77,34 +77,34 @@ func TestCleanAIResponse(t *testing.T) {
 
 func TestCleanAIResponseThinkRegex(t *testing.T) {
 	input2 := "<Think>some reasoning</Think>actual response"
-	result2 := cleanAIResponse(input2)
+	result2 := CleanAIResponse(input2)
 	if result2 != "actual response" {
 		t.Errorf("Valid Think tags should be removed: %q", result2)
 	}
 
 	input3 := "<think\nmultiline\nreasoning</think visible"
-	result3 := cleanAIResponse(input3)
+	result3 := CleanAIResponse(input3)
 	// No closing > on opening tag, so won't match regex
 	if result3 != "<think\nmultiline\nreasoning</think visible" {
 		t.Errorf("Malformed think should not be removed: %q", result3)
 	}
 
 	input4 := "<think type=re>reasoning</think visible"
-	result4 := cleanAIResponse(input4)
+	result4 := CleanAIResponse(input4)
 	// </think followed by space, not >, so won't match
 	if result4 != "<think type=re>reasoning</think visible" {
 		t.Errorf("Malformed closing should not be removed: %q", result4)
 	}
 
 	input_real := "prefix<think reasoning here</think suffix"
-	result_real := cleanAIResponse(input_real)
+	result_real := CleanAIResponse(input_real)
 	// The closing </think has no > after it, so won't match
 	if result_real != "prefix<think reasoning here</think suffix" {
 		t.Errorf("Malformed tags should pass through: %q", result_real)
 	}
 
 	input_valid := "<Think>reasoning</Think>result"
-	result_valid := cleanAIResponse(input_valid)
+	result_valid := CleanAIResponse(input_valid)
 	if result_valid != "result" {
 		t.Errorf("Valid tags should be removed: %q", result_valid)
 	}

internal/platform/exec.go

@@ -17,3 +17,62 @@ func fileContains(path, substr string) bool {
 func execLookPath(name string) (string, error) {
 	return exec.LookPath(name)
 }
+
+func readOSReleaseName() string {
+	data, err := os.ReadFile("/etc/os-release")
+	if err != nil {
+		return ""
+	}
+	var pretty, name, version string
+	for _, line := range strings.Split(string(data), "\n") {
+		key, val, ok := strings.Cut(line, "=")
+		if !ok {
+			continue
+		}
+		val = strings.Trim(val, `"'`)
+		switch key {
+		case "PRETTY_NAME":
+			pretty = val
+		case "NAME":
+			name = val
+		case "VERSION_ID":
+			version = val
+		}
+	}
+	if pretty != "" {
+		return pretty
+	}
+	if name != "" && version != "" {
+		return name + " " + version
+	}
+	return name
+}
+
+func readMacOSVersion() string {
+	out, err := exec.Command("sw_vers", "-productVersion").Output()
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(out))
+}
+
+func readWindowsVersion() string {
+	if v := os.Getenv("OS"); v != "" && strings.Contains(strings.ToLower(v), "windows") {
+		// Try to detect Windows 11 vs 10 via build number
+		if build := os.Getenv("MUYUE_WIN_BUILD"); build != "" {
+			return "Windows " + build
+		}
+	}
+	out, err := exec.Command("cmd", "/c", "ver").Output()
+	if err != nil {
+		return ""
+	}
+	s := strings.TrimSpace(string(out))
+	if strings.Contains(s, "10.0.22") || strings.Contains(s, "10.0.23") {
+		return "Windows 11"
+	}
+	if strings.Contains(s, "10.0.") {
+		return "Windows 10"
+	}
+	return s
+}

internal/platform/platform.go

@@ -25,6 +25,7 @@ const (
 
 type SystemInfo struct {
 	OS             OS     `json:"os"`
+	OSName         string `json:"os_name"`
 	Arch           Arch   `json:"arch"`
 	IsWSL          bool   `json:"is_wsl"`
 	Shell          string `json:"shell"`
@@ -39,6 +40,7 @@ func Detect() SystemInfo {
 	}
 
 	info.IsWSL = detectWSL()
+	info.OSName = detectOSName(info.OS, info.IsWSL)
 	info.Shell = detectShell()
 	info.Terminal = detectTerminal()
 	info.PackageManager = detectPackageManager(info.OS)
@@ -46,6 +48,33 @@ func Detect() SystemInfo {
 	return info
 }
 
+func detectOSName(os OS, isWSL bool) string {
+	switch os {
+	case Linux:
+		if name := readOSReleaseName(); name != "" {
+			if isWSL {
+				return name + " (WSL)"
+			}
+			return name
+		}
+		if isWSL {
+			return "Linux (WSL)"
+		}
+		return "Linux"
+	case MacOS:
+		if v := readMacOSVersion(); v != "" {
+			return "macOS " + v
+		}
+		return "macOS"
+	case Windows:
+		if v := readWindowsVersion(); v != "" {
+			return v
+		}
+		return "Windows"
+	}
+	return string(os)
+}
+
 func detectWSL() bool {
 	return fileContains("/proc/version", "microsoft") ||
 		fileContains("/proc/version", "WSL")
@@ -95,8 +124,11 @@ func detectPackageManager(os OS) string {
 func (s SystemInfo) String() string {
 	parts := []string{
 		"OS: " + string(s.OS),
-		"Arch: " + string(s.Arch),
 	}
+	if s.OSName != "" {
+		parts = append(parts, "Name: "+s.OSName)
+	}
+	parts = append(parts, "Arch: "+string(s.Arch))
 	if s.IsWSL {
 		parts = append(parts, "WSL: yes")
 	}

internal/skills/skills.go

@@ -33,6 +33,7 @@ type Skill struct {
 	Dependencies []SkillDependency `yaml:"dependencies,omitempty" json:"dependencies,omitempty"`
 	Languages    []string          `yaml:"languages,omitempty" json:"languages,omitempty"`
 	Category     string            `yaml:"category,omitempty" json:"category,omitempty"`
+	Deployed     bool              `yaml:"-" json:"deployed,omitempty"`
 }
 
 type ValidationError struct {
@@ -155,6 +156,27 @@ func Delete(name string) error {
 	return nil
 }
 
+func IsDeployed(name string) bool {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return false
+	}
+	crushPath := filepath.Join(home, ".config", "crush", "skills", name, "SKILL.md")
+	claudePath := filepath.Join(home, ".claude", "skills", name, "SKILL.md")
+	_, crushErr := os.Stat(crushPath)
+	_, claudeErr := os.Stat(claudePath)
+	return crushErr == nil || claudeErr == nil
+}
+
+func Undeploy(name string) error {
+	skill, err := Get(name)
+	if err != nil {
+		return err
+	}
+	undeployFromTargets(skill.Name)
+	return nil
+}
+
 func Update(skill *Skill) error {
 	if errs := Validate(skill); len(errs) > 0 {
 		return fmt.Errorf("validation failed: %v", errs)

internal/version/version.go

@@ -7,7 +7,7 @@ import (
 
 const (
 	Name    = "muyue"
-	Version = "0.4.0"
+	Version = "0.7.0"
 	Author  = "La Légion de Muyue"
 )
 

internal/workflow/engine.go

@@ -225,17 +225,21 @@ func (e *Engine) Execute(ctx context.Context, workflowID string, onStep func(ste
 		stepStatuses[step.ID] = StatusPending
 	}
 
-	resolveDeps := func(stepID string) bool {
+	resolveDeps := func(stepID string) (ready bool, blocked bool) {
 		step := wf.findStep(stepID)
 		if step == nil {
-			return false
+			return false, true
 		}
 		for _, dep := range step.DependsOn {
-			if stepStatuses[dep] != StatusDone {
+			depStatus := stepStatuses[dep]
-				return false
+			if depStatus == StatusFailed || depStatus == StatusSkipped {
+				return false, true
+			}
+			if depStatus != StatusDone {
+				return false, false
 			}
 		}
-		return true
+		return true, false
 	}
 
 	executeStep := func(step *Step) error {
@@ -296,6 +300,7 @@ func (e *Engine) Execute(ctx context.Context, workflowID string, onStep func(ste
 				s.Error = stepErr.Error()
 				s.EndedAt = &endTime
 			})
+			stepStatuses[step.ID] = StatusFailed
 			if onStep != nil {
 				onStep(step, "failed")
 			}
@@ -321,8 +326,27 @@ func (e *Engine) Execute(ctx context.Context, workflowID string, onStep func(ste
 			continue
 		}
 
-		for !resolveDeps(step.ID) {
+		ready, blocked := resolveDeps(step.ID)
-			time.Sleep(100 * time.Millisecond)
+		if blocked {
+			e.UpdateStep(workflowID, step.ID, func(s *Step) {
+				s.Status = StatusSkipped
+			})
+			stepStatuses[step.ID] = StatusSkipped
+			if onStep != nil {
+				onStep(&step, "skipped")
+			}
+			continue
+		}
+		if !ready {
+			e.UpdateStep(workflowID, step.ID, func(s *Step) {
+				s.Status = StatusSkipped
+				s.Error = "dependency not satisfied at execution time"
+			})
+			stepStatuses[step.ID] = StatusSkipped
+			if onStep != nil {
+				onStep(&step, "skipped")
+			}
+			continue
 		}
 
 		if err := executeStep(&step); err != nil {

web/src/api/client.js

@@ -36,12 +36,17 @@ const api = {
   testSkill: (name, sampleTask) => request('/skills/test', { method: 'POST', body: JSON.stringify({ name, sample_task: sampleTask || '' }) }),
   exportSkill: (name) => request('/skills/export', { method: 'POST', body: JSON.stringify({ name }) }),
   importSkill: (path) => request('/skills/import', { method: 'POST', body: JSON.stringify({ import_path: path }) }),
+  deploySkill: (name) => request('/skills/deploy', { method: 'POST', body: JSON.stringify({ name }) }),
+  undeploySkill: (name) => request('/skills/undeploy', { method: 'POST', body: JSON.stringify({ name }) }),
   getDashboardStatus: () => request('/dashboard/status'),
   getProvidersQuota: () => request('/providers/quota'),
   getProvidersConsumption: () => request('/providers/consumption'),
   getRecentCommands: () => request('/recent-commands'),
   getRunningProcesses: () => request('/running-processes'),
   getSystemMetrics: () => request('/system/metrics'),
+  getTestSnippet: () => request('/test/snippet'),
+  getTestSessions: () => request('/test/sessions'),
+  getTestConsole: (sessionId) => request(`/test/console/${encodeURIComponent(sessionId || '')}`),
   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) }),
@@ -49,6 +54,7 @@ const api = {
   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 || '' }) }),
+  aiTask: (task, tool) => request('/ai/task', { method: 'POST', body: JSON.stringify({ task, 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) }),
@@ -62,15 +68,15 @@ const api = {
   clearShellChat: () => request('/shell/chat/clear', { method: 'POST' }),
   analyzeSystem: () => request('/shell/analyze', { method: 'POST' }),
   getShellAnalysis: () => request('/shell/analysis'),
-  sendChat: (message, stream = true, onChunk, signal, images = []) => {
+  sendChat: (message, stream = true, onChunk, signal, images = [], advancedReflection = false) => {
     if (!stream) {
-      return request('/chat', { method: 'POST', body: JSON.stringify({ message, stream: false, images }) })
+      return request('/chat', { method: 'POST', body: JSON.stringify({ message, stream: false, images, advanced_reflection: advancedReflection }) })
     }
     return new Promise((resolve, reject) => {
       fetch(`${API_BASE}/chat`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ message, stream: true, images }),
+        body: JSON.stringify({ message, stream: true, images, advanced_reflection: advancedReflection }),
         signal,
       }).then(async (res) => {
         if (!res.ok) {

web/src/components/App.jsx

@@ -1,5 +1,5 @@
 import { useState, useEffect, useCallback, useMemo, useRef } from 'react'
-import { LayoutDashboard, Sparkles, Terminal, Settings } from 'lucide-react'
+import { LayoutDashboard, Sparkles, Terminal, Settings, TestTube2 } from 'lucide-react'
 import api from '../api/client'
 import { getTheme, applyTheme } from '../themes'
 import { useI18n } from '../i18n'
@@ -7,6 +7,7 @@ import Dashboard from './Dashboard'
 import Studio from './Studio'
 import Shell from './Shell'
 import Config from './Config'
+import Tests from './Tests'
 import OnboardingWizard from './OnboardingWizard'
 
 export default function App() {
@@ -16,8 +17,6 @@ export default function App() {
   const [isSudo, setIsSudo] = useState(false)
   const [dashRefreshKey, setDashRefreshKey] = useState(0)
   const dashRefreshRef = useRef(null)
-  const [updates, setUpdates] = useState([])
-  const [tools, setTools] = useState([])
   const [config, setConfig] = useState(null)
   const [showOnboarding, setShowOnboarding] = useState(false)
   const { t, layout } = useI18n()
@@ -26,13 +25,12 @@ export default function App() {
     { id: 'dash', label: t('tabs.dashboard'), icon: <LayoutDashboard size={15} /> },
     { id: 'studio', label: t('tabs.studio'), icon: <Sparkles size={15} /> },
     { id: 'shell', label: t('tabs.shell'), icon: <Terminal size={15} /> },
+    { id: 'tests', label: 'Tests', icon: <TestTube2 size={15} /> },
     { id: 'config', label: t('tabs.config'), icon: <Settings size={15} /> },
   ], [t])
 
   useEffect(() => {
     api.getInfo().then(d => { setInfo(d); setIsSudo(!!d.sudo) }).catch(() => {})
-    api.getTools().then(d => setTools(d.tools || [])).catch(() => {})
-    api.getUpdates().then(d => setUpdates(d.updates || [])).catch(() => {})
     api.getConfig().then(d => {
       setConfig(d)
       const theme = d.profile?.preferences?.theme || 'cyberpunk-red'
@@ -58,7 +56,8 @@ export default function App() {
         Digit1: 'dash',
         Digit2: 'studio',
         Digit3: 'shell',
-        Digit4: 'config',
+        Digit4: 'tests',
+        Digit5: 'config',
       }
       if (map[e.code]) {
         e.preventDefault()
@@ -82,9 +81,6 @@ export default function App() {
     return () => window.removeEventListener('navigate-to-shell', handler)
   }, [])
 
-  const hasUpdates = updates.some(u => u.needsUpdate)
-  const installed = tools.filter(tool => tool.installed).length
-
   const WINDOW_SHORTCUTS = useMemo(() => ({
     dash: [],
     studio: [
@@ -99,6 +95,7 @@ export default function App() {
       { keys: layout.keys.enter, desc: t('statusbar.runCommand') },
       { keys: `${layout.keys.up}/${layout.keys.down}`, desc: t('statusbar.commandHistory') },
     ],
+    tests: [],
     config: [],
   }), [layout, t])
 
@@ -127,17 +124,6 @@ export default function App() {
 
         <div className="header-spacer" />
 
-        <div className="header-indicators">
-          <span
-            className={`indicator ${installed > 0 ? 'ok' : 'off'}`}
-            title={t('header.toolsInstalled', { count: installed })}
-          />
-          <span
-            className={`indicator ${hasUpdates ? 'warn' : 'ok'}`}
-            title={hasUpdates ? t('header.updatesAvailable') : t('header.upToDate')}
-          />
-        </div>
-
         <span className="header-clock">
           {clock.toLocaleTimeString(layout.locale, { hour: '2-digit', minute: '2-digit' })}
         </span>
@@ -146,7 +132,8 @@ export default function App() {
       <main className="content">
         <div className={activeTab === 'dash' ? '' : 'tab-hidden'}><Dashboard api={api} refreshRef={dashRefreshRef} /></div>
         <div className={activeTab === 'studio' ? '' : 'tab-hidden'}><Studio api={api} /></div>
-        <div className={activeTab === 'shell' ? '' : 'tab-hidden'}><Shell api={api} /></div>
+        <div className={activeTab === 'shell' ? '' : 'tab-hidden'}><Shell api={api} isSudo={isSudo} /></div>
+        <div className={activeTab === 'tests' ? '' : 'tab-hidden'}><Tests api={api} /></div>
         <div className={activeTab === 'config' ? '' : 'tab-hidden'}><Config api={api} /></div>
       </main>
 

web/src/components/Config.jsx

@@ -1,11 +1,10 @@
 import { useState, useEffect, useCallback } from 'react'
-import { User, Brain, RefreshCw, Wrench, Monitor, AlertTriangle } from 'lucide-react'
+import { User, Brain, Wrench, Monitor, AlertTriangle, Bot, Sparkles, Zap, GitBranch, Container, Circle, Hexagon, Code, Rocket, Download } from 'lucide-react'
 import { useI18n } from '../i18n'
 
 const PANELS = [
   { id: 'profile', icon: User },
   { id: 'providers', icon: Brain },
-  { id: 'updates', icon: RefreshCw },
   { id: 'skills', icon: Wrench },
   { id: 'system', icon: Monitor },
 ]
@@ -16,10 +15,7 @@ export default function Config({ api }) {
   const [config, setConfig] = useState(null)
   const [providers, setProviders] = useState([])
   const [skillList, setSkillList] = useState([])
-  const [updates, setUpdates] = useState([])
+
-  const [tools, setTools] = useState([])
-  const [checking, setChecking] = useState(false)
-  const [updating, setUpdating] = useState(null)
   const [editProfile, setEditProfile] = useState(false)
   const [editProvider, setEditProvider] = useState(null)
   const [profileForm, setProfileForm] = useState({})
@@ -34,8 +30,6 @@ export default function Config({ api }) {
     }).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])
 
@@ -46,31 +40,6 @@ export default function Config({ api }) {
     setTimeout(() => setToast(null), 2500)
   }
 
-  const handleCheckUpdates = async () => {
-    setChecking(true)
-    try {
-      await api.runScan()
-      const d = await api.getUpdates()
-      setUpdates(d.updates || [])
-      const td = await api.getTools()
-      setTools(td.tools || [])
-      showToast(t('config.upToDate'))
-    } catch (err) {
-      showToast(`${t('config.error')}: ${err.message}`)
-    }
-    setChecking(false)
-  }
-
-  const handleUpdateTool = (tool) => {
-    window.dispatchEvent(new CustomEvent('navigate-to-shell', {}))
-    window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: `Met à jour l'outil ${tool} sur mon système. Exécute les commandes nécessaires.` } }))
-  }
-
-  const handleUpdateAll = () => {
-    const toUpdate = updates.filter(u => u.needsUpdate).map(u => u.tool)
-    window.dispatchEvent(new CustomEvent('navigate-to-shell', {}))
-    window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: `Met à jour tous les outils suivants sur mon système : ${toUpdate.join(', ')}. Exécute les commandes nécessaires une par une.` } }))
-  }
 
   const handleSaveProfile = async () => {
     try {
@@ -109,9 +78,7 @@ export default function Config({ api }) {
     setEditProvider(p.name)
   }
 
-  const needsUpdateCount = updates.filter(u => u.needsUpdate).length
+
-  const installedCount = tools.filter(tool => tool.installed).length
-  const missingCount = tools.filter(tool => !tool.installed).length
 
   return (
     <div className="config-window">
@@ -152,20 +119,8 @@ export default function Config({ api }) {
               t={t}
             />
           )}
-          {activePanel === 'updates' && (
-            <PanelUpdates
-              updates={updates} tools={tools}
-              checking={checking} updating={updating}
-              needsUpdateCount={needsUpdateCount}
-              installedCount={installedCount} missingCount={missingCount}
-              handleCheckUpdates={handleCheckUpdates}
-              handleUpdateTool={handleUpdateTool}
-              handleUpdateAll={handleUpdateAll}
-              t={t}
-            />
-          )}
           {activePanel === 'skills' && (
-            <PanelSkills skillList={skillList} t={t} />
+            <PanelSkills skillList={skillList} api={api} loadData={loadData} t={t} />
           )}
           {activePanel === 'system' && (
             <PanelSystem api={api} t={t} />
@@ -406,180 +361,80 @@ function PanelProviders({ providers, editProvider, providerForm, setProviderForm
   )
 }
 
-function PanelUpdates({ updates, tools, checking, updating, needsUpdateCount, installedCount, missingCount, handleCheckUpdates, handleUpdateTool, handleUpdateAll, t }) {
+function PanelSkills({ skillList, api, loadData, t }) {
-  const handleInstallTool = (tool) => {
+  const [deploying, setDeploying] = useState(null)
-    window.dispatchEvent(new CustomEvent('navigate-to-shell', {}))
+
-    window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: `Installe l'outil ${tool} sur mon système. Vérifie d'abord s'il est déjà installé, puis installe-le si nécessaire avec les commandes appropriées.` } }))
+  const handleDeploy = async (name) => {
+    setDeploying(name + '-deploy')
+    try {
+      await api.deploySkill(name)
+      loadData()
+    } catch (err) {
+      console.error('deploy skill:', err)
+    }
+    setDeploying(null)
   }
 
-  const missingTools = tools.filter(tool => !tool.installed)
+  const handleUndeploy = async (name) => {
-
+    setDeploying(name + '-undeploy')
-  return (
+    try {
-    <>
+      await api.undeploySkill(name)
-      <div className="config-card">
+      loadData()
-        <div className="config-update-controls">
+    } catch (err) {
-          <div className="config-update-stats">
+      console.error('undeploy skill:', err)
-            <span className="badge ok">{installedCount} {t('config.installed')}</span>
+    }
-            {missingCount > 0 && <span className="badge error">{missingCount} {t('config.missing')}</span>}
+    setDeploying(null)
-            {needsUpdateCount > 0 && <span className="badge warn">{needsUpdateCount} {t('config.needsUpdate')}</span>}
+  }
-          </div>
-          <div className="config-update-buttons">
-            <button className="sm" onClick={handleCheckUpdates} disabled={checking}>
-              {checking ? <><RefreshCw size={12} className="spin-icon" /> {t('config.checking')}</> : t('config.checkUpdates')}
-            </button>
-            {needsUpdateCount > 0 && (
-              <button className="sm primary" onClick={handleUpdateAll} disabled={updating === '__all__'}>
-                {updating === '__all__' ? t('config.updating') : `${t('config.updateAll')} (${needsUpdateCount})`}
-              </button>
-            )}
-          </div>
-        </div>
-      </div>
-
-      {missingTools.length > 0 && (
-        <>
-          <div className="section-title" style={{ marginTop: 12, marginBottom: 4 }}>{t('config.missing') || 'Modules manquants'}</div>
-          <div className="config-update-list">
-            {missingTools.map((tool, i) => (
-              <div key={`miss-${i}`} className="config-update-row">
-                <div className="config-update-info">
-                  <span className="config-update-name">{tool.name}</span>
-                  <span className="config-update-versions">
-                    <span style={{ color: 'var(--danger)' }}>{t('config.notInstalled') || 'Non installé'}</span>
-                  </span>
-                </div>
-                <button
-                  className="sm primary"
-                  onClick={() => handleInstallTool(tool.name)}
-                >
-                  {t('config.install') || 'Installer'}
-                </button>
-              </div>
-            ))}
-          </div>
-        </>
-      )}
-
-      {updates.length === 0 ? (
-        <div className="config-card">
-          <div className="empty-state">{t('config.noUpdates')}</div>
-        </div>
-      ) : (
-        <div className="config-update-list">
-          {updates.map((u, i) => (
-            <div key={i} className="config-update-row">
-              <div className="config-update-info">
-                <span className="config-update-name">{u.tool}</span>
-                <span className="config-update-versions">
-                  {u.needsUpdate ? (
-                    <>{u.current} → <span style={{ color: 'var(--warning)' }}>{u.latest}</span></>
-                  ) : (
-                    <span style={{ color: 'var(--success)' }}>{u.current}</span>
-                  )}
-                </span>
-              </div>
-              {u.needsUpdate && (
-                <button
-                  className="sm"
-                  onClick={() => handleUpdateTool(u.tool)}
-                  disabled={updating === u.tool}
-                >
-                  {updating === u.tool ? t('config.updating') : t('config.updateTool')}
-                </button>
-              )}
-            </div>
-          ))}
-        </div>
-      )}
-    </>
-  )
-}
-
-
-
-function PanelSkills({ skillList, t }) {
-  const [selected, setSelected] = useState(null)
 
   if (skillList.length === 0) {
     return <div className="empty-state" style={{ color: 'var(--text-disabled)', padding: 40 }}>{t('config.noSkills')}</div>
   }
 
   return (
-    <>
+    <div className="skills-list">
-      <div className="skill-tiles">
+      {skillList.map((s, i) => (
-        {skillList.map((s, i) => (
+        <div key={i} className="config-update-row" style={{ alignItems: 'center' }}>
-          <div key={i} className="skill-tile" onClick={() => setSelected(s)}>
+          <div className="skill-list-info">
-            <div className="skill-tile-name">{s.name}</div>
+            <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
-            <div className="skill-tile-desc">{s.description}</div>
+              <span className="config-update-name">{s.name}</span>
-            <div className="skill-tile-tags">
+              {s.deployed ? (
-              {s.target && <span className="badge neutral">{s.target}</span>}
+                <span className="badge ok">{t('config.installed')}</span>
-              {s.version && <span className="badge">{s.version}</span>}
+              ) : (
-              {s.category && <span className="badge" style={{ opacity: 0.7 }}>{s.category}</span>}
+                <span className="badge neutral">{t('config.notInstalled')}</span>
+              )}
             </div>
+            <div style={{ fontSize: 11, color: 'var(--text-tertiary)', marginTop: 2 }}>{s.description}</div>
           </div>
-        ))}
+          <div style={{ display: 'flex', gap: 6, flexShrink: 0 }}>
-      </div>
+            <button
-      {selected && (
+              className="sm primary"
-        <div className="skill-detail-overlay" onClick={() => setSelected(null)}>
+              disabled={s.deployed || deploying === s.name + '-deploy'}
-          <div className="skill-detail-panel" onClick={e => e.stopPropagation()}>
+              onClick={() => handleDeploy(s.name)}
-            <div className="skill-detail-header">
+            >
-              <span className="skill-detail-name">{selected.name}</span>
+              {deploying === s.name + '-deploy' ? '...' : t('config.apply')}
-              <button className="ghost sm" onClick={() => setSelected(null)}>✕</button>
+            </button>
-            </div>
+            <button
-            <div className="skill-detail-body">
+              className="sm ghost"
-              <div className="skill-detail-section">
+              disabled={!s.deployed || deploying === s.name + '-undeploy'}
-                <div className="skill-detail-label">Description</div>
+              onClick={() => handleUndeploy(s.name)}
-                <div style={{ fontSize: 13, color: 'var(--text-secondary)' }}>{selected.description}</div>
+            >
-              </div>
+              {deploying === s.name + '-undeploy' ? '...' : t('config.remove')}
-              <div className="skill-detail-section">
+            </button>
-                <div className="skill-detail-label">Métadonnées</div>
-                <div className="skill-detail-meta">
-                  {selected.target && <span className="badge neutral">{selected.target}</span>}
-                  {selected.version && <span className="badge">{selected.version}</span>}
-                  {selected.category && <span className="badge">{selected.category}</span>}
-                  {selected.author && <span className="badge ghost">{selected.author}</span>}
-                  {selected.languages && selected.languages.map(l => <span key={l} className="badge ghost">{l}</span>)}
-                </div>
-              </div>
-              {selected.tags && selected.tags.length > 0 && (
-                <div className="skill-detail-section">
-                  <div className="skill-detail-label">Tags</div>
-                  <div className="chip-row">
-                    {selected.tags.map(tag => <span key={tag} className="badge">{tag}</span>)}
-                  </div>
-                </div>
-              )}
-              {selected.content && (
-                <div className="skill-detail-section">
-                  <div className="skill-detail-label">Contenu</div>
-                  <div className="skill-detail-content">{selected.content}</div>
-                </div>
-              )}
-              {selected.dependencies && selected.dependencies.length > 0 && (
-                <div className="skill-detail-section">
-                  <div className="skill-detail-label">Dépendances</div>
-                  <div className="skill-detail-deps">
-                    {selected.dependencies.map((d, i) => (
-                      <div key={i} className="skill-detail-dep">
-                        <span className="badge">{d.type}</span>
-                        <span>{d.name}</span>
-                        {d.required === false && <span style={{ fontSize: 11, color: 'var(--text-disabled)' }}>optionnel</span>}
-                      </div>
-                    ))}
-                  </div>
-                </div>
-              )}
-            </div>
           </div>
         </div>
-      )}
+      ))}
-    </>
+    </div>
   )
 }
 
 function PanelSystem({ api, t }) {
   const [showResetModal, setShowResetModal] = useState(false)
   const [toast, setToast] = useState(null)
+  const [isSudo, setIsSudo] = useState(false)
+
+  useEffect(() => {
+    api.getInfo().then(d => setIsSudo(!!d.sudo)).catch(() => {})
+  }, [api])
 
   const showToast = (msg) => {
     setToast(msg)
@@ -597,26 +452,123 @@ function PanelSystem({ api, t }) {
     }
   }
 
-  const handleApplyStarship = () => {
+  const handleSystemUpdate = () => {
-    window.dispatchEvent(new CustomEvent('navigate-to-shell', {}))
+    window.dispatchEvent(new CustomEvent('navigate-to-shell'))
-    window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: `Vérifie si starship est installé sur le système. S'il ne l'est pas, installe-le (avec curl ou le gestionnaire de paquets). Ensuite, applique la configuration du thème "charm" pour starship. Assure-toi que starship est bien initialisé dans le shell de l'utilisateur.` } }))
+    if (isSudo) {
+      window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: `Mets à jour le système et tous les outils utilisés par l'application Muyue. Exécute les commandes suivantes dans l'ordre :\n1. Met à jour les paquets système : sudo apt update && sudo apt upgrade -y\n2. Installe les dépendances utiles si manquantes : sudo apt install -y sshpass git curl wget\n3. Mets à jour les outils installés : crush, claude, gh, go, node/npm, python3/pip3/uv, docker, starship\n4. Pour chaque outil, vérifie la version actuelle, mets à jour si possible, puis vérifie la nouvelle version\n5. Donne un récapitulatif final de tout ce qui a été mis à jour ou installé` } }))
+    } else {
+      window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: `Je n'ai pas les droits sudo sur ce système. Donne-moi les commandes nécessaires pour mettre à jour le système et les outils suivants. Pour chaque outil, indique la commande exacte à exécuter :\n1. Paquets système (apt update && apt upgrade)\n2. Outils à mettre à jour : crush, claude, gh, go, node/npm, python3/pip3/uv, docker, starship\n3. Dépendances utiles à installer : sshpass, git, curl, wget\n4. Présente les commandes dans un tableau markdown avec le nom de l'outil, la commande, et si sudo est requis` } }))
+    }
   }
 
+  const configureTool = (tool) => {
+    window.dispatchEvent(new CustomEvent('navigate-to-shell'))
+    window.dispatchEvent(new CustomEvent('ask-ai-terminal', { detail: { message: tool.prompt } }))
+  }
+
+  const AI_TOOLS = [
+    {
+      id: 'crush',
+      name: 'Crush',
+      icon: 'Zap',
+      description: t('config.toolCrushDesc'),
+      prompt: `Configure l'outil Crush sur ce système. Vérifie d'abord s'il est installé avec "crush --version". S'il n'est pas installé, installe-le avec la méthode appropriée (npm install -g @anthropic/crush ou via le script officiel). S'il est déjà installé, vérifie sa configuration dans ~/.config/crush/ et affiche son état. Demande-moi les informations nécessaires si besoin (clés API, préférences, etc.).`,
+    },
+    {
+      id: 'claude',
+      name: 'Claude Code',
+      icon: 'Bot',
+      description: t('config.toolClaudeDesc'),
+      prompt: `Configure l'outil Claude Code (claude) sur ce système. Vérifie d'abord s'il est installé avec "claude --version". S'il n'est pas installé, installe-le avec npm install -g @anthropic-ai/claude-code. S'il est installé, vérifie sa configuration et son authentification. Demande-moi les informations nécessaires si besoin (clé API Anthropic, etc.).`,
+    },
+    {
+      id: 'gh',
+      name: 'GitHub CLI',
+      icon: 'GitBranch',
+      description: t('config.toolGhDesc'),
+      prompt: `Configure l'outil GitHub CLI (gh) sur ce système. Vérifie d'abord s'il est installé avec "gh --version". S'il n'est pas installé, installe-le avec la méthode appropriée pour ce système. S'il est installé, vérifie son authentification avec "gh auth status". Si non authentifié, guide-moi pour le configurer avec "gh auth login". Demande-moi le token si nécessaire.`,
+    },
+    {
+      id: 'docker',
+      name: 'Docker',
+      icon: 'Container',
+      description: t('config.toolDockerDesc'),
+      prompt: `Configure Docker sur ce système. Vérifie d'abord s'il est installé avec "docker --version". Vérifie aussi si le daemon tourne avec "docker info". S'il n'est pas installé, installe-le avec la méthode appropriée. Vérifie que l'utilisateur est dans le groupe docker. Si des problèmes de permissions existent, explique comment les résoudre.`,
+    },
+    {
+      id: 'go',
+      name: 'Go',
+      icon: 'Circle',
+      description: t('config.toolGoDesc'),
+      prompt: `Configure l'environnement Go sur ce système. Vérifie s'il est installé avec "go version". Vérifie le GOPATH, GOROOT et les variables d'environnement. S'il n'est pas installé, installe-le avec la méthode appropriée. Vérifie que les binaires Go sont dans le PATH.`,
+    },
+    {
+      id: 'node',
+      name: 'Node.js',
+      icon: 'Hexagon',
+      description: t('config.toolNodeDesc'),
+      prompt: `Configure l'environnement Node.js sur ce système. Vérifie s'il est installé avec "node --version" et "npm --version". Vérifie aussi pnpm et npx. S'il n'est pas installé, installe-le avec la méthode recommandée (nvm, fnm ou le gestionnaire de paquets). Vérifie la version LTS vs Current.`,
+    },
+    {
+      id: 'python',
+      name: 'Python',
+      icon: 'Code',
+      description: t('config.toolPythonDesc'),
+      prompt: `Configure l'environnement Python sur ce système. Vérifie python3 --version, pip3 --version, et uv --version. S'ils ne sont pas installés, installe-les avec la méthode appropriée. Vérifie les paquets essentiels (venv, pip). Configure uv si nécessaire.`,
+    },
+    {
+      id: 'starship',
+      name: 'Starship',
+      icon: 'Rocket',
+      description: t('config.toolStarshipDesc'),
+      prompt: `Configure Starship (prompt shell) sur ce système. Vérifie s'il est installé avec "starship --version". S'il n'est pas installé, installe-le. Ensuite, configure le thème "charm" dans ~/.config/starship.toml. Assure-toi que starship est initialisé dans le shell de l'utilisateur (.bashrc, .zshrc ou config fish).`,
+    },
+  ]
+
+  const ICON_MAP = { Zap, Bot, GitBranch, Container, Circle, Hexagon, Code, Rocket }
+
   return (
     <>
       {toast && <div className="config-toast">{toast}</div>}
 
-      <div className="section-title" style={{ marginBottom: 8 }}>Configuration Système</div>
+      <div className="section-title" style={{ marginBottom: 8 }}>{t('config.systemConfig')}</div>
-      <div className="config-card">
+
-        <div className="config-card-row" style={{ marginBottom: 16 }}>
+      <div className="section-title" style={{ marginTop: 4, marginBottom: 8, fontSize: 12, color: 'var(--text-tertiary)', textTransform: 'none', letterSpacing: 0 }}>
-          <span className="config-card-label" style={{ fontWeight: 600 }}>{t('config.applyStarship')}</span>
+        <Bot size={13} style={{ verticalAlign: 'middle', marginRight: 6 }} />
+        {t('config.aiToolsConfig')}
+      </div>
+      <div className="config-ai-tools-grid">
+        {AI_TOOLS.map(tool => {
+          const Icon = ICON_MAP[tool.icon] || Bot
+          return (
+            <div key={tool.id} className="config-ai-tool-card">
+              <div className="config-ai-tool-header">
+                <span className="config-ai-tool-icon"><Icon size={16} /></span>
+                <span className="config-ai-tool-name">{tool.name}</span>
+              </div>
+              <div className="config-ai-tool-desc">{tool.description}</div>
+              <button className="sm primary" onClick={() => configureTool(tool)} style={{ marginTop: 'auto' }}>
+                <Sparkles size={12} style={{ verticalAlign: 'middle', marginRight: 4 }} />
+                {t('config.configureViaAI')}
+              </button>
+            </div>
+          )
+        })}
+      </div>
+
+      <div className="config-card" style={{ marginTop: 12, marginBottom: 4 }}>
+        <div className="config-card-row" style={{ alignItems: 'center' }}>
+          <div>
+            <span className="config-card-label" style={{ fontWeight: 600 }}>{t('config.systemUpdate')}</span>
+            <div style={{ fontSize: 11, color: 'var(--text-tertiary)', marginTop: 2 }}>
+              {isSudo ? t('config.systemUpdateDescSudo') : t('config.systemUpdateDescNoSudo')}
+            </div>
+          </div>
+          <button className="sm primary" onClick={handleSystemUpdate}>
+            <Download size={12} style={{ verticalAlign: 'middle', marginRight: 4 }} />
+            {t('config.updateBtn')}
+          </button>
         </div>
-        <div style={{ fontSize: 12, color: 'var(--text-tertiary)', marginBottom: 12 }}>
-          Vérifie l'installation de starship et configure le thème charm via l'IA.
-        </div>
-        <button className="sm primary" onClick={handleApplyStarship}>
-          {t('config.applyStarship')}
-        </button>
       </div>
 
       <div className="section-title" style={{ marginTop: 20, marginBottom: 8, color: 'var(--danger)' }}>

web/src/components/Shell.jsx

@@ -1,4 +1,4 @@
-import { useState, useRef, useEffect, useCallback, useMemo } from 'react'
+import { useState, useRef, useEffect, useCallback, useMemo, memo, Fragment } from 'react'
 import { Terminal as XTerm } from '@xterm/xterm'
 import { FitAddon } from '@xterm/addon-fit'
 import { WebLinksAddon } from '@xterm/addon-web-links'
@@ -214,7 +214,6 @@ function getTheme(themeName) {
 }
 
 function createTerminal(container, settings = {}) {
-  console.log('[Shell] createTerminal called with settings:', JSON.stringify({ fontSize: settings.fontSize, fontFamily: settings.fontFamily?.slice(0, 30), theme: settings.theme }))
   const theme = getTheme(settings.theme || 'system')
   const actualFontSize = settings.fontSize || 14
   const term = new XTerm({
@@ -225,6 +224,7 @@ function createTerminal(container, settings = {}) {
     theme,
     allowTransparency: false,
     scrollback: 5000,
+    bracketedPaste: false,
   })
 
   const fitAddon = new FitAddon()
@@ -362,7 +362,7 @@ function connectWebSocket(term, fitAddon, initPayload, onStateChange, onFirstMes
   return ws
 }
 
-export default function Shell({ api }) {
+export default function Shell({ api, isSudo }) {
   const { t } = useI18n()
   const tabsRef = useRef({})
   const nextIdRef = useRef(1)
@@ -408,6 +408,7 @@ export default function Shell({ api }) {
   })
   const activeTabRef = useRef(activeTab)
   useEffect(() => { activeTabRef.current = activeTab }, [activeTab])
+  const tabIdsKey = useMemo(() => tabs.map(t => t.id).join(','), [tabs])
   const [sshConnections, setSshConnections] = useState([])
   const [systemTerminals, setSystemTerminals] = useState([])
   const [showMenu, setShowMenu] = useState(false)
@@ -456,8 +457,9 @@ export default function Shell({ api }) {
   }, [])
 
   const [sshForm, setSshForm] = useState({
-    name: '', host: '', port: 22, user: '', key_path: '',
+    name: '', host: '', port: 22, user: '', key_path: '', password: '',
   })
+  const [sshEditing, setSshEditing] = useState(null)
 
   const [aiMessages, setAiMessages] = useState([])
   const [aiInput, setAiInput] = useState('')
@@ -472,8 +474,22 @@ export default function Shell({ api }) {
   const aiLoadedRef = useRef(false)
   const aiLoadingRef = useRef(false)
   const analysisSavingRef = useRef(false)
+  const _streamRafRef = useRef(null)
+  const _streamPendingRef = useRef(null)
+
+  const _flushStreamUpdate = useCallback(() => {
+    _streamRafRef.current = null
+    const pending = _streamPendingRef.current
+    if (!pending) return
+    _streamPendingRef.current = null
+    setAiMessages(pending)
+  }, [])
 
   useEffect(() => {
+    if (_streamRafRef.current) {
+      cancelAnimationFrame(_streamRafRef.current)
+      _streamRafRef.current = null
+    }
     aiMessagesRef.current?.scrollTo(0, aiMessagesRef.current.scrollHeight)
   }, [aiMessages])
 
@@ -511,20 +527,15 @@ export default function Shell({ api }) {
       setSystemTerminals(d.system || [])
     }).catch(() => {})
     api.getConfig().then(d => {
-      console.log('[Shell] config response terminal:', JSON.stringify(d?.terminal))
       if (d.terminal) {
         const fontSize = d.terminal.font_size || 14
         const fontFamily = d.terminal.font_family || "'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'SF Mono', 'Menlo', monospace"
         const theme = d.terminal.theme || 'system'
-        console.log('[Shell] setting fontSize to:', fontSize, 'from config')
         setTerminalSettings({ fontSize, fontFamily, theme })
         settingsRef.current = { fontSize, fontFamily, theme }
         baseFontSizeRef.current = fontSize
-      } else {
-        console.log('[Shell] no terminal config in response, using defaults')
       }
       setConfigLoaded(true)
-      console.log('[Shell] configLoaded = true, settingsRef:', JSON.stringify(settingsRef.current))
     }).catch((err) => { console.warn('[Shell] getConfig failed:', err); setConfigLoaded(true) })
   }, [])
 
@@ -536,7 +547,6 @@ export default function Shell({ api }) {
 
     const s = settingsRef.current
     const effectiveFontSize = s.fontSize + zoomLevel * 2
-    console.log(`[Shell] initTerminal tab=${tabId}: settingsRef.fontSize=${s.fontSize}, zoomLevel=${zoomLevel}, effectiveFontSize=${effectiveFontSize}`)
     const { term, fitAddon, searchAddon } = createTerminal(container, {
       fontSize: effectiveFontSize,
       fontFamily: s.fontFamily,
@@ -552,6 +562,7 @@ export default function Shell({ api }) {
           port: tab.port || 22,
           user: tab.user || 'root',
           key_path: tab.key_path || '',
+          password: tab.password || '',
         }),
       }
     } else {
@@ -628,14 +639,11 @@ export default function Shell({ api }) {
 
     const bufferSaveInterval = setInterval(() => { if (!disposed) saveBuffer() }, 5000)
 
-    console.log(`[Shell] initTerminal tab=${tabId} type=${tab.type} name="${tab.name}" shell="${tab.shell || '(default)'}"`)
     tabsRef.current[tabId] = { term, fitAddon, searchAddon, ws, resizeObserver, onResize, bufferSaveInterval, saveBuffer, disposed: () => disposed }
     tabsRef.current[tabId]._markDisposed = () => { disposed = true }
-    console.log(`[Shell] initTerminal tab=${tabId} done, tabsRef keys:`, Object.keys(tabsRef.current))
 
     const pending = pendingCommandsRef.current[tabId]
     if (pending && pending.length > 0) {
-      console.log(`[Shell] Flushing ${pending.length} pending commands for tab ${tabId}`)
       for (const cmd of pending) {
         if (ws.readyState === WebSocket.OPEN) {
           ws.send(JSON.stringify({ type: 'input', data: cmd + '\r' }))
@@ -691,7 +699,6 @@ export default function Shell({ api }) {
     const tryInitTab = (tab, attempt) => {
       if (cancelled) return
       if (attempt > 20) {
-        console.warn(`[Shell] max attempts reached for tab ${tab.id}`)
         return
       }
       
@@ -715,7 +722,6 @@ export default function Shell({ api }) {
       }
       
       if (!tabsRef.current[tab.id]) {
-        console.log(`[Shell] tryInitTab: calling initTerminal for tab ${tab.id}, configLoaded=${configLoaded}`)
         initTerminal(tab.id, tab)
       }
       
@@ -734,7 +740,6 @@ export default function Shell({ api }) {
       })
     }
 
-    console.log(`[Shell] init effect: tabs=${tabs.length}, configLoaded=${configLoaded}`)
     for (const tab of tabs) {
       if (configLoaded && !tabsRef.current[tab.id]) {
         tryInitTab(tab, 0)
@@ -757,7 +762,7 @@ export default function Shell({ api }) {
       pending.forEach(clearTimeout)
       observer?.disconnect()
     }
-  }, [tabs, initTerminal, initPendingTabs, configLoaded])
+  }, [tabIdsKey, initTerminal, initPendingTabs, configLoaded])
 
   useEffect(() => {
     const entry = tabsRef.current[activeTab]
@@ -775,12 +780,18 @@ export default function Shell({ api }) {
       const wrapper = document.querySelector('.shell-layout')?.parentElement
       if (wrapper && wrapper.classList.contains('tab-hidden')) return
       const entry = tabsRef.current[activeTabRef.current]
-      if (entry) {
+      if (entry && entry.fitAddon && entry.term) {
-        entry.fitAddon.fit()
+        const container = document.getElementById(`terminal-${activeTabRef.current}`)
+        if (!container) return
+        const rect = container.getBoundingClientRect()
+        const dims = entry.fitAddon.proposeDimensions()
+        if (dims && (entry.term.cols !== dims.cols || entry.term.rows !== dims.rows)) {
+          entry.fitAddon.fit()
+        }
       }
     }, 2000)
     return () => clearInterval(iv)
-  }, [tabs])
+  }, [tabIdsKey])
 
   useEffect(() => {
     return () => {
@@ -810,25 +821,26 @@ export default function Shell({ api }) {
       if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA') return
       if (!e.altKey && !(e.key === 'Tab' && e.shiftKey)) return
 
+      const currentTabs = tabsRef.current._tabList || []
       if (e.key === 'Tab' && e.shiftKey) {
         const shellTab = document.querySelector('.shell-layout')
         if (!shellTab || shellTab.closest('.tab-hidden')) return
         e.preventDefault()
-        const idx = tabs.findIndex(t => t.id === activeTab)
+        const idx = currentTabs.findIndex(t => t.id === activeTabRef.current)
-        const next = (idx + 1) % tabs.length
+        const next = (idx + 1) % currentTabs.length
-        setActiveTab(tabs[next].id)
+        setActiveTab(currentTabs[next].id)
         return
       }
 
       const num = parseInt(e.key)
-      if (num >= 1 && num <= tabs.length) {
+      if (num >= 1 && num <= currentTabs.length) {
         e.preventDefault()
-        setActiveTab(tabs[num - 1].id)
+        setActiveTab(currentTabs[num - 1].id)
       }
     }
     window.addEventListener('keydown', onKey)
     return () => window.removeEventListener('keydown', onKey)
-  }, [tabs])
+  }, [])
 
   useEffect(() => {
     if (showSearch && searchInputRef.current) {
@@ -893,6 +905,7 @@ export default function Shell({ api }) {
       port: conn.port || 22,
       user: conn.user || 'root',
       key_path: conn.key_path || '',
+      password: conn.password || '',
       connected: false,
     }
     setTabs(prev => { const next = [...prev, newTab]; localStorage.setItem(TABS_STORAGE_KEY, JSON.stringify(next.map(t => ({ id: t.id, name: t.name, type: t.type, shell: t.shell, host: t.host, port: t.port, user: t.user, key_path: t.key_path })))); return next })
@@ -963,14 +976,26 @@ export default function Shell({ api }) {
     if (!sshForm.name.trim() || !sshForm.host.trim()) return
     try {
       await api.addSSHConnection(sshForm)
-      setSshConnections(prev => [...prev, { ...sshForm }])
+      if (sshEditing) {
-      setSshForm({ name: '', host: '', port: 22, user: '', key_path: '' })
+        setSshConnections(prev => prev.map(c => c.name === sshEditing ? { ...sshForm } : c))
+      } else {
+        setSshConnections(prev => [...prev, { ...sshForm }])
+      }
+      setSshForm({ name: '', host: '', port: 22, user: '', key_path: '', password: '' })
+      setSshEditing(null)
       setShowSshModal(false)
     } catch (err) {
       console.error(err)
     }
   }
 
+  const editSSHConnection = (conn) => {
+    setSshForm({ name: conn.name, host: conn.host, port: conn.port || 22, user: conn.user || '', key_path: conn.key_path || '', password: conn.password || '' })
+    setSshEditing(conn.name)
+    setShowSshModal(true)
+    setShowMenu(false)
+  }
+
   const deleteSSHConnection = async (name) => {
     try {
       await api.deleteSSHConnection(name)
@@ -995,7 +1020,6 @@ export default function Shell({ api }) {
       pendingCommandsRef.current[targetId].push(code)
       return
     }
-    console.log(`[Shell] sendToTerminal: tab ${targetId} ← ${code.length} chars`)
     entry.ws.send(JSON.stringify({ type: 'input', data: code + '\r' }))
   }, [])
 
@@ -1082,21 +1106,35 @@ export default function Shell({ api }) {
     }
 
     const currentTab = activeTabRef.current
-    console.log(`[Shell] _sendAiMessage: activeTab=${currentTab}, fromEvent=${fromEvent}, text="${trimmed.slice(0, 50)}"`)
     setAiMessages(prev => [...prev, { role: 'user', content: trimmed, _tabId: currentTab, _analysis: isAnalysis || undefined }])
     setAiLoading(true)
 
     try {
-      let accumulated = ''
+      let segments = []
-      let toolCalls = []
+      let textStartIdx = 0
       const controller = new AbortController()
 
+      const _updateLastText = (text) => {
+        if (!text) return
+        const last = segments.length > 0 ? segments[segments.length - 1] : null
+        if (last && last.type === 'text') {
+          last.content = text
+        } else {
+          segments.push({ type: 'text', content: text })
+        }
+      }
+
       await api.sendShellChat(trimmed, {}, true, (partial, event) => {
         if (event && event.tool_call) {
-          toolCalls = [...toolCalls, { call: event.tool_call, result: null }]
+          _updateLastText(partial.slice(textStartIdx))
+          textStartIdx = partial.length
+          segments.push({ type: 'tool', call: event.tool_call, result: null })
+          const snap = segments.map(s => ({ ...s, ...(s.type === 'tool' ? { call: s.call, result: s.result } : {}) }))
+          if (_streamRafRef.current) { cancelAnimationFrame(_streamRafRef.current); _streamRafRef.current = null }
+          _streamPendingRef.current = null
           setAiMessages(prev => {
             const filtered = prev.filter(m => !m._streaming)
-            return [...filtered, { role: 'assistant', content: accumulated, _streaming: true, _tabId: currentTab, _toolCalls: [...toolCalls] }]
+            return [...filtered, { role: 'assistant', _streaming: true, _tabId: currentTab, _segments: snap }]
           })
           return
         }
@@ -1104,12 +1142,15 @@ export default function Shell({ api }) {
           if (event.tool_result.sudo_blocked) {
             setSudoModal({ command: event.tool_result.command || event.tool_result.content })
           }
-          const idx = toolCalls.findIndex(tc => tc.call && tc.call.tool_call_id === event.tool_result.tool_call_id)
+          const segIdx = segments.findIndex(s => s.type === 'tool' && s.call && s.call.tool_call_id === event.tool_result.tool_call_id)
-          if (idx >= 0) {
+          if (segIdx >= 0) {
-            toolCalls[idx] = { ...toolCalls[idx], result: event.tool_result }
+            segments[segIdx].result = event.tool_result
+            const snap = segments.map(s => ({ ...s, ...(s.type === 'tool' ? { call: s.call, result: s.result } : {}) }))
+            if (_streamRafRef.current) { cancelAnimationFrame(_streamRafRef.current); _streamRafRef.current = null }
+            _streamPendingRef.current = null
             setAiMessages(prev => {
               const filtered = prev.filter(m => !m._streaming)
-              return [...filtered, { role: 'assistant', content: accumulated, _streaming: true, _tabId: currentTab, _toolCalls: [...toolCalls] }]
+              return [...filtered, { role: 'assistant', _streaming: true, _tabId: currentTab, _segments: snap }]
             })
           }
           return
@@ -1117,23 +1158,37 @@ export default function Shell({ api }) {
         if (event && (event.thinking !== undefined || event.thinking_end)) {
           return
         }
-        accumulated = partial
+        _updateLastText(partial.slice(textStartIdx))
-        setAiMessages(prev => {
+        const nextMsgs = prev => {
           const filtered = prev.filter(m => !m._streaming)
-          return [...filtered, { role: 'assistant', content: partial, _streaming: true, _tabId: currentTab, _toolCalls: toolCalls.length > 0 ? [...toolCalls] : undefined }]
+          const snap = segments.map(s => ({ ...s, ...(s.type === 'tool' ? { call: s.call, result: s.result } : {}) }))
-        })
+          return [...filtered, { role: 'assistant', _streaming: true, _tabId: currentTab, _segments: snap }]
+        }
+        _streamPendingRef.current = nextMsgs
+        if (!_streamRafRef.current) {
+          _streamRafRef.current = requestAnimationFrame(_flushStreamUpdate)
+        }
       }, controller.signal)
 
-      const finalMsg = { role: 'assistant', content: accumulated, _tabId: currentTab }
+      if (_streamRafRef.current) { cancelAnimationFrame(_streamRafRef.current); _streamRafRef.current = null }
-      if (toolCalls.length > 0) {
+      _streamPendingRef.current = null
-        finalMsg._toolCalls = toolCalls
+
+      const allText = segments.filter(s => s.type === 'text').map(s => s.content).join('')
+      const toolSegs = segments.filter(s => s.type === 'tool')
+
+      const finalMsg = { role: 'assistant', content: allText, _tabId: currentTab }
+      if (toolSegs.length > 0 || segments.length > 1) {
         finalMsg.content = JSON.stringify({
-          content: accumulated,
+          segments: segments.map(s => s.type === 'text'
-          tool_calls: toolCalls.map(tc => tc.call),
+            ? { type: 'text', content: s.content }
-          tool_results: toolCalls.map(tc => ({
+            : { type: 'tool', call: s.call, result: { content: s.result?.content || '', is_error: s.result?.is_error || false, tool_call_id: s.call?.tool_call_id } }
-            tool_call_id: tc.call?.tool_call_id,
+          ),
-            result: tc.result?.content || '',
+          content: allText,
-            is_error: tc.result?.is_error || false,
+          tool_calls: toolSegs.map(s => s.call),
+          tool_results: toolSegs.map(s => ({
+            tool_call_id: s.call?.tool_call_id,
+            result: s.result?.content || '',
+            is_error: s.result?.is_error || false,
           })),
         })
       }
@@ -1143,10 +1198,10 @@ export default function Shell({ api }) {
         return [...filtered, finalMsg]
       })
 
-      if (analysisSavingRef.current && accumulated) {
+      if (analysisSavingRef.current && allText) {
         analysisSavingRef.current = false
-        setAnalysisContent(accumulated)
+        setAnalysisContent(allText)
-        try { localStorage.setItem('shell_analysis', accumulated) } catch {}
+        try { localStorage.setItem('shell_analysis', allText) } catch {}
         setAnalyzing(false)
       }
 
@@ -1166,7 +1221,7 @@ export default function Shell({ api }) {
     }
     setAiLoading(false)
     aiLoadingRef.current = false
-  }, [api, t, aiAtLimit, focusAiTerminal])
+  }, [api, t, aiAtLimit, focusAiTerminal, _flushStreamUpdate])
 
   const handleAiSend = () => _sendAiMessage(aiInput, false)
 
@@ -1174,7 +1229,7 @@ export default function Shell({ api }) {
     const handler = (e) => {
       const msg = e.detail?.message
       if (!msg) return
-      setAiInput(msg)
+      setAiInput('')
       setTimeout(() => _sendAiMessage(msg, true), 100)
     }
     window.addEventListener('ask-ai-terminal', handler)
@@ -1300,6 +1355,13 @@ Sois concret : cite les vraies versions, les vrais chemins, les vrais nombres. L
                             <span>{conn.name}</span>
                             <span className="shell-menu-item-sub">{conn.user}@{conn.host}:{conn.port}</span>
                           </button>
+                          <button
+                            className="shell-menu-item-icon"
+                            onClick={(e) => { e.stopPropagation(); editSSHConnection(conn) }}
+                            title={t('shell.editConnection')}
+                          >
+                            <Pencil size={11} />
+                          </button>
                           <button
                             className="shell-menu-item-icon"
                             onClick={(e) => { e.stopPropagation(); deleteSSHConnection(conn.name) }}
@@ -1355,8 +1417,9 @@ Sois concret : cite les vraies versions, les vrais chemins, les vrais nombres. L
 
       <div className="shell-ai-col">
         <div className="ai-panel-header">
-          <span>Analyste Système</span>
+          <span style={{ flex: 1 }}>Analyste Système</span>
-          <div style={{ display: 'flex', gap: 6 }}>
+          <div style={{ display: 'flex', alignItems: 'center', gap: 6, flexShrink: 0 }}>
+            <span className={`sudo-indicator ${isSudo ? 'sudo-ok' : 'sudo-blocked'}`} title={isSudo ? 'Sudo sans mot de passe disponible' : 'Sudo bloqué — mot de passe requis'} />
             <button
               className="shell-analyze-btn"
               onClick={() => setShowAnalysis(true)}
@@ -1468,15 +1531,16 @@ Sois concret : cite les vraies versions, les vrais chemins, les vrais nombres. L
       )}
 
       {showSshModal && (
-        <div className="shell-modal-overlay" onClick={() => setShowSshModal(false)}>
+        <div className="shell-modal-overlay" onClick={() => { setShowSshModal(false); setSshEditing(null) }}>
           <div className="shell-modal" onClick={e => e.stopPropagation()}>
-            <div className="shell-modal-header">{t('shell.addConnection')}</div>
+            <div className="shell-modal-header">{sshEditing ? t('shell.editConnection') : t('shell.addConnection')}</div>
             <div className="shell-modal-body">
               <label className="shell-modal-label">{t('shell.connectionName')}</label>
               <input
                 value={sshForm.name}
                 onChange={e => setSshForm(f => ({ ...f, name: e.target.value }))}
                 placeholder="prod-server"
+                disabled={!!sshEditing}
               />
               <label className="shell-modal-label">{t('shell.host')}</label>
               <input
@@ -1508,9 +1572,16 @@ Sois concret : cite les vraies versions, les vrais chemins, les vrais nombres. L
                 onChange={e => setSshForm(f => ({ ...f, key_path: e.target.value }))}
                 placeholder="~/.ssh/id_rsa"
               />
+              <label className="shell-modal-label">{t('shell.password')} <span style={{ fontWeight: 400, fontSize: 10, color: 'var(--text-disabled)' }}>({t('shell.passwordHint')})</span></label>
+              <input
+                type="password"
+                value={sshForm.password}
+                onChange={e => setSshForm(f => ({ ...f, password: e.target.value }))}
+                placeholder="••••••"
+              />
             </div>
             <div className="shell-modal-footer">
-              <button className="ghost" onClick={() => setShowSshModal(false)}>{t('shell.cancel')}</button>
+              <button className="ghost" onClick={() => { setShowSshModal(false); setSshEditing(null) }}>{t('shell.cancel')}</button>
               <button className="primary" onClick={saveSSHConnection}>{t('shell.save')}</button>
             </div>
           </div>
@@ -1593,7 +1664,39 @@ function MermaidBlock({ code }) {
   return <div className="shell-mermaid-container" ref={ref} dangerouslySetInnerHTML={{ __html: svg }} />
 }
 
-function ShellAIMessage({ msg, sendToTerminal, terminalTabId }) {
+const _renderParts = (parts, copiedIdx, setCopiedIdx, sendToTerminal, terminalTabId) => parts.map((part, i) => {
+  if (part.type === 'code' && part.lang === 'mermaid') {
+    return (
+      <div key={i} className="shell-code-block">
+        <div className="shell-code-lang">mermaid</div>
+        <MermaidBlock code={part.content} />
+      </div>
+    )
+  }
+  if (part.type === 'code') {
+    return (
+      <div key={i} className="shell-code-block">
+        {part.lang && <div className="shell-code-lang">{part.lang}</div>}
+        <pre><code>{part.content}</code></pre>
+        <div className="shell-code-actions">
+          <button className={copiedIdx === i ? 'copied' : ''} onClick={() => {
+            navigator.clipboard.writeText(part.content)
+            setCopiedIdx(i)
+            setTimeout(() => setCopiedIdx(null), 1500)
+          }} title="Copier">
+            <Copy size={12} /> {copiedIdx === i ? 'Copié !' : 'Copier'}
+          </button>
+          <button onClick={() => sendToTerminal(part.content, terminalTabId)} title="Envoyer au terminal">
+            <Send size={12} /> Terminal
+          </button>
+        </div>
+      </div>
+    )
+  }
+  return <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
+})
+
+const ShellAIMessage = memo(function ShellAIMessage({ msg, sendToTerminal, terminalTabId }) {
   const role = msg.role === 'user' ? 'user' : msg.role === 'system' ? 'system' : 'assistant'
   const content = msg.content || ''
   const [copiedIdx, setCopiedIdx] = useState(null)
@@ -1606,18 +1709,51 @@ function ShellAIMessage({ msg, sendToTerminal, terminalTabId }) {
     return <div className={`ai-message system`}>{content}</div>
   }
 
+  // Ordered segments (streaming or final with segments)
+  let segments = msg._segments || null
+  if (!segments) {
+    try {
+      const parsed = JSON.parse(content)
+      if (parsed && Array.isArray(parsed.segments)) {
+        segments = parsed.segments
+      }
+    } catch {}
+  }
+
+  if (segments && segments.length > 0) {
+    const hasTools = segments.some(s => s.type === 'tool')
+    if (hasTools) {
+      return (
+        <div className="ai-message assistant">
+          {segments.map((seg, i) => {
+            if (seg.type === 'text') {
+              if (!seg.content) return null
+              return <Fragment key={`t${i}`}>{_renderParts(renderContent(seg.content), copiedIdx, setCopiedIdx, sendToTerminal, terminalTabId)}</Fragment>
+            }
+            if (seg.type === 'tool') {
+              const r = seg.result
+              const result = r && (r.content !== undefined || r.is_error !== undefined)
+                ? { content: r.content, is_error: r.is_error }
+                : null
+              return <ShellToolBlock key={`tc${i}`} call={seg.call} result={result} />
+            }
+            return null
+          })}
+        </div>
+      )
+    }
+  }
+
+  // Fallback: old format (all tools then all text)
   let parsedToolCalls = null
   let parsedToolResults = null
   let displayContent = content
-  let streamingToolCalls = msg._toolCalls || null
 
   try {
     const parsed = JSON.parse(content)
     if (parsed && Array.isArray(parsed.tool_calls)) {
-      if (!streamingToolCalls) {
+      parsedToolCalls = parsed.tool_calls
-        parsedToolCalls = parsed.tool_calls
+      parsedToolResults = parsed.tool_results || null
-        parsedToolResults = parsed.tool_results || null
-      }
       displayContent = parsed.content || ''
     }
   } catch {}
@@ -1626,9 +1762,6 @@ function ShellAIMessage({ msg, sendToTerminal, terminalTabId }) {
 
   return (
     <div className={`ai-message assistant`}>
-      {streamingToolCalls && streamingToolCalls.map((tc, i) => (
-        <ShellToolBlock key={tc.call?.tool_call_id || i} call={tc.call} result={tc.result} />
-      ))}
       {parsedToolCalls && parsedToolCalls.map((tc, i) => {
         const resultData = parsedToolResults
           ? parsedToolResults.find(r => r.tool_call_id === tc.tool_call_id)
@@ -1638,37 +1771,7 @@ function ShellAIMessage({ msg, sendToTerminal, terminalTabId }) {
           : null
         return <ShellToolBlock key={tc.tool_call_id || i} call={tc} result={result} />
       })}
-      {parts.map((part, i) => {
+      {_renderParts(parts, copiedIdx, setCopiedIdx, sendToTerminal, terminalTabId)}
-        if (part.type === 'code' && part.lang === 'mermaid') {
-          return (
-            <div key={i} className="shell-code-block">
-              <div className="shell-code-lang">mermaid</div>
-              <MermaidBlock code={part.content} />
-            </div>
-          )
-        }
-        if (part.type === 'code') {
-          return (
-            <div key={i} className="shell-code-block">
-              {part.lang && <div className="shell-code-lang">{part.lang}</div>}
-              <pre><code>{part.content}</code></pre>
-              <div className="shell-code-actions">
-                <button className={copiedIdx === i ? 'copied' : ''} onClick={() => {
-                  navigator.clipboard.writeText(part.content)
-                  setCopiedIdx(i)
-                  setTimeout(() => setCopiedIdx(null), 1500)
-                }} title="Copier">
-                  <Copy size={12} /> {copiedIdx === i ? 'Copié !' : 'Copier'}
-                </button>
-                <button onClick={() => sendToTerminal(part.content, terminalTabId)} title="Envoyer au terminal">
-                  <Send size={12} /> Terminal
-                </button>
-              </div>
-            </div>
-          )
-        }
-        return <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
-      })}
     </div>
   )
-}
+})

web/src/components/Studio.jsx

@@ -142,10 +142,17 @@ const TOOL_LABELS = {
   web_fetch: 'Web Fetch',
 }
 
-function ToolCallBlock({ call, result }) {
+function ToolCallBlock({ call, result, activeAgents, onModeChange }) {
   const icon = TOOL_ICONS[call.name] || '🔧'
   const label = TOOL_LABELS[call.name] || call.name
   const isErr = result && result.is_error
+  const isCrush = call.name === 'crush_run'
+  const isClaude = call.name === 'claude_run'
+  const isAgent = isCrush || isClaude
+  const agentType = isCrush ? 'crush' : isClaude ? 'claude' : null
+  const maxAgents = isCrush ? 2 : isClaude ? 2 : 0
+  const currentCount = agentType && activeAgents ? (activeAgents[agentType] || 0) : 0
+  const [mode, setMode] = useState('sync')
 
   let argsPreview = ''
   try {
@@ -163,15 +170,39 @@ function ToolCallBlock({ call, result }) {
 
   const truncatedResult = result ? (result.content || '').slice(0, 2000) : null
 
+  const handleModeChange = (newMode) => {
+    setMode(newMode)
+    if (onModeChange) onModeChange(call.tool_call_id, newMode)
+  }
+
   return (
     <div className={`studio-tool-block ${isErr ? 'error' : ''} ${result ? 'done' : 'running'}`}>
       <div className="studio-tool-header">
         <span className="studio-tool-icon">{icon}</span>
         <span className="studio-tool-name">{label}</span>
+        {isAgent && !result && (
+          <span className="studio-agent-badge">{currentCount}/{maxAgents}</span>
+        )}
         {!result && <span className="studio-tool-spinner"><span/><span/><span/></span>}
         {result && <span className={`studio-tool-status ${isErr ? 'error' : 'ok'}`}>{isErr ? '✗' : '✓'}</span>}
       </div>
       <div className="studio-tool-args" title={argsPreview}>{argsPreview}</div>
+      {isAgent && !result && (
+        <div className="studio-agent-mode">
+          <button
+            className={`studio-mode-btn ${mode === 'sync' ? 'active' : ''}`}
+            onClick={() => handleModeChange('sync')}
+          >
+            Exécuter et attendre
+          </button>
+          <button
+            className={`studio-mode-btn ${mode === 'async' ? 'active' : ''}`}
+            onClick={() => handleModeChange('async')}
+          >
+            Exécuter en arrière-plan
+          </button>
+        </div>
+      )}
       {truncatedResult && (
         <div className="studio-tool-result">
           <pre>{truncatedResult}</pre>
@@ -239,20 +270,27 @@ function CodeBlockWithCopy({ part, index, copiedIdx, setCopiedIdx }) {
   )
 }
 
-function FeedItem({ msg }) {
+function FeedItem({ msg, activeAgents, onModeChange, collapseHistory }) {
   const isUser = msg.role === 'user'
   const isSystem = msg.role === 'system'
   const rank = getRank(msg.role)
   const [copiedIdx, setCopiedIdx] = useState(null)
+  const [forceExpand, setForceExpand] = useState(false)
 
   const timeStr = msg.time ? new Date(msg.time).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : ''
 
   let parsedToolCalls = null
   let parsedToolResults = null
+  let parsedSegments = null
   let displayContent = msg.content
   try {
     const parsed = JSON.parse(msg.content)
-    if (parsed && Array.isArray(parsed.tool_calls)) {
+    if (parsed && Array.isArray(parsed.segments)) {
+      parsedSegments = parsed.segments
+      parsedToolCalls = parsed.tool_calls || null
+      parsedToolResults = parsed.tool_results || null
+      displayContent = parsed.content || ''
+    } else if (parsed && Array.isArray(parsed.tool_calls)) {
       parsedToolCalls = parsed.tool_calls
       parsedToolResults = parsed.tool_results || null
       displayContent = parsed.content || ''
@@ -292,36 +330,106 @@ function FeedItem({ msg }) {
             ))}
           </div>
         )}
-        {parsedToolCalls && parsedToolCalls.map((tc, i) => {
+        {parsedSegments && parsedSegments.some(s => s.type === 'tool') ? (
-          const resultData = parsedToolResults
+          (() => {
-            ? parsedToolResults.find(r => r.tool_call_id === tc.tool_call_id)
+            const toolSegs = parsedSegments.filter(s => s.type === 'tool')
-            : null
+            const compress = collapseHistory && !forceExpand && toolSegs.length > 1
-          const result = resultData
+            const lastTool = toolSegs.length > 0 ? toolSegs[toolSegs.length - 1] : null
-            ? { content: resultData.result, is_error: resultData.is_error }
+            return (
-            : null
+              <>
-          return <ToolCallBlock key={tc.tool_call_id || i} call={tc} result={result} />
+                {compress && (
-        })}
+                  <div className="feed-content" style={{ opacity: 0.7, fontSize: '0.85em', display: 'flex', justifyContent: 'space-between' }}>
-        {cleanContent && (
+                    <span>… {toolSegs.length - 1} action{toolSegs.length - 1 > 1 ? 's' : ''} précédente{toolSegs.length - 1 > 1 ? 's' : ''} masquée{toolSegs.length - 1 > 1 ? 's' : ''}</span>
-          <div className="feed-content">
+                    <button
-            {renderContent(cleanContent).map((part, i) =>
+                      type="button"
-              part.type === 'code' ? (
+                      onClick={() => setForceExpand(true)}
-                <CodeBlockWithCopy key={i} part={part} index={i} copiedIdx={copiedIdx} setCopiedIdx={setCopiedIdx} />
+                      style={{ background: 'transparent', border: 'none', color: 'var(--accent, #6c5ce7)', cursor: 'pointer', fontSize: 'inherit' }}
-              ) : (
+                    >Tout afficher</button>
-                <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
+                  </div>
+                )}
+                {parsedSegments.map((seg, i) => {
+                  if (seg.type === 'text') {
+                    if (!seg.content) return null
+                    const c = seg.content.replace(/<think[^>]*>[\s\S]*?<\/think>/gi, '')
+                    if (!c) return null
+                    return (
+                      <div key={`t${i}`} className="feed-content">
+                        {renderContent(c).map((part, j) =>
+                          part.type === 'code' ? (
+                            <CodeBlockWithCopy key={j} part={part} index={j} copiedIdx={copiedIdx} setCopiedIdx={setCopiedIdx} />
+                          ) : (
+                            <span key={j} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
+                          )
+                        )}
+                      </div>
+                    )
+                  }
+                  if (seg.type === 'tool') {
+                    if (compress && seg !== lastTool) return null
+                    const r = seg.result
+                    const result = r && (r.content !== undefined || r.is_error !== undefined)
+                      ? { content: r.content, is_error: r.is_error }
+                      : null
+                    return <ToolCallBlock key={`tc${i}`} call={seg.call} result={result} activeAgents={activeAgents} onModeChange={onModeChange} />
+                  }
+                  return null
+                })}
+              </>
+            )
+          })()
+        ) : (
+          <>
+            {parsedToolCalls && (() => {
+              const compress = collapseHistory && !forceExpand && parsedToolCalls.length > 1
+              const items = compress ? parsedToolCalls.slice(-1) : parsedToolCalls
+              return (
+                <>
+                  {compress && (
+                    <div className="feed-content" style={{ opacity: 0.7, fontSize: '0.85em', display: 'flex', justifyContent: 'space-between' }}>
+                      <span>… {parsedToolCalls.length - 1} action{parsedToolCalls.length - 1 > 1 ? 's' : ''} précédente{parsedToolCalls.length - 1 > 1 ? 's' : ''} masquée{parsedToolCalls.length - 1 > 1 ? 's' : ''}</span>
+                      <button
+                        type="button"
+                        onClick={() => setForceExpand(true)}
+                        style={{ background: 'transparent', border: 'none', color: 'var(--accent, #6c5ce7)', cursor: 'pointer', fontSize: 'inherit' }}
+                      >Tout afficher</button>
+                    </div>
+                  )}
+                  {items.map((tc, i) => {
+                    const resultData = parsedToolResults
+                      ? parsedToolResults.find(r => r.tool_call_id === tc.tool_call_id)
+                      : null
+                    const result = resultData
+                      ? { content: resultData.result, is_error: resultData.is_error }
+                      : null
+                    return <ToolCallBlock key={tc.tool_call_id || i} call={tc} result={result} activeAgents={activeAgents} onModeChange={onModeChange} />
+                  })}
+                </>
               )
+            })()}
+            {cleanContent && (
+              <div className="feed-content">
+                {renderContent(cleanContent).map((part, i) =>
+                  part.type === 'code' ? (
+                    <CodeBlockWithCopy key={i} part={part} index={i} copiedIdx={copiedIdx} setCopiedIdx={setCopiedIdx} />
+                  ) : (
+                    <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
+                  )
+                )}
+              </div>
             )}
-          </div>
+          </>
         )}
       </div>
     </div>
   )
 }
 
-function StreamingItem({ content, thinking, toolCalls }) {
+function StreamingItem({ content, thinking, toolCalls, segments, activeAgents, onModeChange, collapseHistory }) {
   const rank = RANKS.general
   const cleanContent = content.replace(/<think[^>]*>[\s\S]*?<\/think>/gi, '')
   const hasToolCalls = toolCalls && toolCalls.length > 0
   const [copiedIdx, setCopiedIdx] = useState(null)
+  const [forceExpand, setForceExpand] = useState(false)
 
   const renderedContent = useMemo(() => {
     if (!cleanContent) return []
@@ -333,6 +441,10 @@ function StreamingItem({ content, thinking, toolCalls }) {
     return formatText(thinking)
   }, [thinking])
 
+  const hasOrderedSegments = segments && segments.some(s => s.type === 'tool')
+  const toolSegments = (segments || []).filter(s => s.type === 'tool')
+  const compress = collapseHistory && !forceExpand && toolSegments.length > 1
+
   return (
     <div className="feed-item assistant">
       <div className="feed-avatar ai-rank">
@@ -346,25 +458,73 @@ function StreamingItem({ content, thinking, toolCalls }) {
           <span className="feed-role">{rank.label}</span>
         </div>
         {thinking && <ThinkingBlock content={formattedThinking} raw done={false} />}
-        {hasToolCalls && toolCalls.map((tc, i) => (
+        {hasOrderedSegments ? (
-          <ToolCallBlock key={tc.call?.tool_call_id || i} call={tc.call} result={tc.result} />
+          <>
-        ))}
+            {compress && (
-        {!thinking && !cleanContent && !hasToolCalls && (
+              <div className="feed-content" style={{ opacity: 0.7, fontSize: '0.85em', display: 'flex', justifyContent: 'space-between' }}>
+                <span>… {toolSegments.length - 1} action{toolSegments.length - 1 > 1 ? 's' : ''} précédente{toolSegments.length - 1 > 1 ? 's' : ''} masquée{toolSegments.length - 1 > 1 ? 's' : ''} (mode compressé)</span>
+                <button
+                  type="button"
+                  onClick={() => setForceExpand(true)}
+                  style={{ background: 'transparent', border: 'none', color: 'var(--accent, #6c5ce7)', cursor: 'pointer', fontSize: 'inherit' }}
+                >Tout afficher</button>
+              </div>
+            )}
+            {(() => {
+              const lastToolId = toolSegments.length > 0 ? toolSegments[toolSegments.length - 1] : null
+              return segments.map((seg, i) => {
+                if (seg.type === 'text') {
+                  if (!seg.content) return null
+                  const parts = renderContent(seg.content)
+                  return (
+                    <div key={`t${i}`} className="feed-content">
+                      {parts.map((part, j) =>
+                        part.type === 'code' ? (
+                          <CodeBlockWithCopy key={j} part={part} index={j} copiedIdx={copiedIdx} setCopiedIdx={setCopiedIdx} />
+                        ) : (
+                          <span key={j} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
+                        )
+                      )}
+                    </div>
+                  )
+                }
+                if (seg.type === 'tool') {
+                  if (compress && seg !== lastToolId) return null
+                  return <ToolCallBlock key={`tc${i}`} call={seg.call} result={seg.result} activeAgents={activeAgents} onModeChange={onModeChange} />
+                }
+                return null
+              })
+            })()}
+          </>
+        ) : (
+          <>
+            {hasToolCalls && (compress
+              ? [<ToolCallBlock key={toolCalls[toolCalls.length - 1].call?.tool_call_id || 'last'} call={toolCalls[toolCalls.length - 1].call} result={toolCalls[toolCalls.length - 1].result} activeAgents={activeAgents} onModeChange={onModeChange} />]
+              : toolCalls.map((tc, i) => (
+                <ToolCallBlock key={tc.call?.tool_call_id || i} call={tc.call} result={tc.result} activeAgents={activeAgents} onModeChange={onModeChange} />
+              ))
+            )}
+            {cleanContent && (
+              <div className="feed-content">
+                {renderedContent.map((part, i) =>
+                  part.type === 'code' ? (
+                    <CodeBlockWithCopy key={i} part={part} index={i} copiedIdx={copiedIdx} setCopiedIdx={setCopiedIdx} />
+                  ) : (
+                    <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
+                  )
+                )}
+                <span className="studio-cursor" />
+              </div>
+            )}
+          </>
+        )}
+        {!thinking && !cleanContent && !hasToolCalls && !hasOrderedSegments && (
           <div className="feed-content">
             <div className="studio-thinking"><span /><span /><span /></div>
           </div>
         )}
-        {cleanContent && (
+        {!hasOrderedSegments && cleanContent && (
-          <div className="feed-content">
+          <span className="studio-cursor" />
-            {renderedContent.map((part, i) =>
-              part.type === 'code' ? (
-                <CodeBlockWithCopy key={i} part={part} index={i} copiedIdx={copiedIdx} setCopiedIdx={setCopiedIdx} />
-              ) : (
-                <span key={i} dangerouslySetInnerHTML={{ __html: formatText(part.content) }} />
-              )
-            )}
-            <span className="studio-cursor" />
-          </div>
         )}
       </div>
     </div>
@@ -379,12 +539,23 @@ export default function Studio({ api }) {
   const [streaming, setStreaming] = useState('')
   const [streamThinking, setStreamThinking] = useState('')
   const [streamToolCalls, setStreamToolCalls] = useState([])
+  const [streamSegments, setStreamSegments] = useState(null)
   const [loaded, setLoaded] = useState(false)
   const [tokenInfo, setTokenInfo] = useState({ used: 0, max: 150000, summarizeAt: 120000 })
   const [contextCollapsed, setContextCollapsed] = useState(false)
   const [messagesCollapsed, setMessagesCollapsed] = useState(false)
   const [sudoModal, setSudoModal] = useState(null)
   const [attachedImages, setAttachedImages] = useState([])
+  const [activeAgents, setActiveAgents] = useState({ crush: 0, claude: 0 })
+  const [toolModes, setToolModes] = useState({})
+  const [advancedReflection, setAdvancedReflection] = useState(() => {
+    try { return localStorage.getItem('muyue.advancedReflection') === 'true' } catch { return false }
+  })
+  const [collapseHistory, setCollapseHistory] = useState(() => {
+    try { return localStorage.getItem('muyue.collapseHistory') !== 'false' } catch { return true }
+  })
+  const MAX_CRUSH_AGENTS = 2
+  const MAX_CLAUDE_AGENTS = 2
   const messagesEnd = useRef(null)
   const feedRef = useRef(null)
   const textareaRef = useRef(null)
@@ -584,9 +755,19 @@ export default function Studio({ api }) {
     abortRef.current = controller
 
     try {
-      let accumulated = ''
+      let segments = []
+      let textStartIdx = 0
       let thinking = ''
-      let toolCalls = []
+
+      const _updateLastText = (text) => {
+        if (!text) return
+        const last = segments.length > 0 ? segments[segments.length - 1] : null
+        if (last && last.type === 'text') {
+          last.content = text
+        } else {
+          segments.push({ type: 'text', content: text })
+        }
+      }
 
       await api.sendChat(text, true, (partial, event) => {
         if (event && (event.thinking_start || event.thinking_end || event.thinking !== undefined)) {
@@ -597,28 +778,47 @@ export default function Studio({ api }) {
           return
         }
         if (event && event.tool_call) {
-          toolCalls = [...toolCalls, { call: event.tool_call, result: null }]
+          _updateLastText(partial.slice(textStartIdx))
-          setStreamToolCalls([...toolCalls])
+          textStartIdx = partial.length
-          accumulated = ''
+          segments.push({ type: 'tool', call: event.tool_call, result: null })
-          setStreaming('')
+          const toolName = event.tool_call.name
+          if (toolName === 'crush_run' || toolName === 'claude_run') {
+            const agentType = toolName === 'crush_run' ? 'crush' : 'claude'
+            setActiveAgents(prev => ({ ...prev, [agentType]: prev[agentType] + 1 }))
+          }
+          const snap = segments.map(s => ({ ...s }))
+          setStreamToolCalls(snap.filter(s => s.type === 'tool'))
+          setStreamSegments(snap)
+          setStreaming(partial)
           return
         }
         if (event && event.tool_result) {
           if (event.tool_result.sudo_blocked) {
             setSudoModal({ command: event.tool_result.command || event.tool_result.content })
           }
-          const idx = toolCalls.findIndex(tc => tc.call && tc.call.tool_call_id === event.tool_result.tool_call_id)
+          const segIdx = segments.findIndex(s => s.type === 'tool' && s.call && s.call.tool_call_id === event.tool_result.tool_call_id)
-          if (idx >= 0) {
+          if (segIdx >= 0) {
-            toolCalls[idx] = { ...toolCalls[idx], result: event.tool_result }
+            segments[segIdx].result = event.tool_result
-            setStreamToolCalls([...toolCalls])
+            const toolName = segments[segIdx].call?.name
+            if (toolName === 'crush_run' || toolName === 'claude_run') {
+              const agentType = toolName === 'crush_run' ? 'crush' : 'claude'
+              setActiveAgents(prev => ({ ...prev, [agentType]: Math.max(0, prev[agentType] - 1) }))
+            }
+            const snap = segments.map(s => ({ ...s }))
+            setStreamToolCalls(snap.filter(s => s.type === 'tool'))
+            setStreamSegments(snap)
           }
           return
         }
-        accumulated = partial
+        _updateLastText(partial.slice(textStartIdx))
         setStreaming(partial)
-      }, controller.signal, images)
+        const snap = segments.map(s => ({ ...s }))
+        setStreamSegments(snap)
+      }, controller.signal, images, advancedReflection)
 
-      const finalContent = accumulated || t('studio.noResponse')
+      const allText = segments.filter(s => s.type === 'text').map(s => s.content).join('')
+      const toolSegs = segments.filter(s => s.type === 'tool')
+      const finalContent = allText || t('studio.noResponse')
       const aiMsg = {
         id: (Date.now() + 1).toString(),
         role: 'assistant',
@@ -626,14 +826,18 @@ export default function Studio({ api }) {
         time: new Date().toISOString(),
       }
       if (thinking) aiMsg.thinking = thinking
-      if (toolCalls.length > 0) {
+      if (toolSegs.length > 0 || segments.length > 1) {
         aiMsg.content = JSON.stringify({
-          content: finalContent,
+          segments: segments.map(s => s.type === 'text'
-          tool_calls: toolCalls.map(tc => tc.call),
+            ? { type: 'text', content: s.content }
-          tool_results: toolCalls.map(tc => ({
+            : { type: 'tool', call: s.call, result: { content: s.result?.content || '', is_error: s.result?.is_error || false, tool_call_id: s.call?.tool_call_id } }
-            tool_call_id: tc.call?.tool_call_id,
+          ),
-            result: tc.result?.content || '',
+          content: allText,
-            is_error: tc.result?.is_error || false,
+          tool_calls: toolSegs.map(s => s.call),
+          tool_results: toolSegs.map(s => ({
+            tool_call_id: s.call?.tool_call_id,
+            result: s.result?.content || '',
+            is_error: s.result?.is_error || false,
           })),
         })
       }
@@ -661,6 +865,9 @@ export default function Studio({ api }) {
       setStreaming('')
       setStreamThinking('')
       setStreamToolCalls([])
+      setStreamSegments(null)
+      setActiveAgents({ crush: 0, claude: 0 })
+      setToolModes({})
       abortRef.current = null
       refreshTokens()
     }
@@ -672,6 +879,10 @@ export default function Studio({ api }) {
     }
   }, [])
 
+  const handleToolModeChange = useCallback((toolCallId, mode) => {
+    setToolModes(prev => ({ ...prev, [toolCallId]: mode }))
+  }, [])
+
   const COMMANDS = ['/clear', '/summarize', '/help', '/model', '/model change']
 
   const handleKeyDown = (e) => {
@@ -695,30 +906,62 @@ export default function Studio({ api }) {
       if (afterSlash) {
         const partial = afterSlash[0]
         const matches = COMMANDS.filter(c => c.startsWith(partial) && c !== partial)
-        if (matches.length === 1) {
+        if (matches.length >= 1) {
-          const completed = matches[0] + ' '
+          let completed = matches[0]
-          const newText = val.slice(0, pos - afterSlash[0].length) + completed + val.slice(pos)
+          for (const m of matches) {
-          setInput(newText)
+            while (!m.startsWith(completed)) completed = completed.slice(0, -1)
-          requestAnimationFrame(() => {
+          }
-            ta.selectionStart = ta.selectionEnd = pos - afterSlash[0].length + completed.length
+          if (completed === partial && matches.length === 1) completed = matches[0]
-          })
+          if (completed.length > partial.length) {
+            const suffix = completed[completed.length - 1] === ' ' ? '' : (matches.length === 1 ? ' ' : '')
+            completed += suffix
+            const newText = val.slice(0, pos - afterSlash[0].length) + completed + val.slice(pos)
+            setInput(newText)
+            requestAnimationFrame(() => {
+              ta.selectionStart = ta.selectionEnd = pos - afterSlash[0].length + completed.length
+            })
+          }
         }
       }
     }
   }
 
+  const [summarizedExpanded, setSummarizedExpanded] = useState(false)
+
   const handleToggleCollapsed = useCallback(() => {
     setMessagesCollapsed(prev => !prev)
   }, [])
 
   const renderMessages = () => {
-    if (messagesCollapsed && messages.length > 4) {
+    const summarizedMsgs = messages.filter(m => m.summarized)
+    const activeMsgs = messages.filter(m => !m.summarized)
+
+    const renderSummaryBlock = () => summarizedMsgs.length > 0 && (
+      <div className="feed-summary-block">
+        <div className="feed-summary-header" onClick={() => setSummarizedExpanded(prev => !prev)}>
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+            <path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z"/>
+            <polyline points="14 2 14 8 20 8"/>
+            <line x1="16" y1="13" x2="8" y2="13"/>
+            <line x1="16" y1="17" x2="8" y2="17"/>
+          </svg>
+          <span className="feed-summary-text">Résumé · {summarizedMsgs.length} messages</span>
+          <span className="feed-summary-toggle">{summarizedExpanded ? 'masquer' : 'voir'}</span>
+        </div>
+        {summarizedExpanded && summarizedMsgs.map(msg => (
+          <FeedItem key={msg.id} msg={msg} activeAgents={activeAgents} onModeChange={handleToolModeChange} collapseHistory={collapseHistory} />
+        ))}
+      </div>
+    )
+
+    if (messagesCollapsed && activeMsgs.length > 4) {
       const visibleCount = 4
-      const hiddenCount = messages.length - visibleCount
+      const hiddenCount = activeMsgs.length - visibleCount
       return (
         <>
-          {messages.slice(0, visibleCount).map(msg => (
+          {renderSummaryBlock()}
-            <FeedItem key={msg.id} msg={msg} />
+          {activeMsgs.slice(0, visibleCount).map(msg => (
+            <FeedItem key={msg.id} msg={msg} activeAgents={activeAgents} onModeChange={handleToolModeChange} collapseHistory={collapseHistory} />
           ))}
           <div className="feed-collapsed-messages" onClick={handleToggleCollapsed}>
             <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
@@ -730,9 +973,15 @@ export default function Studio({ api }) {
         </>
       )
     }
-    return messages.map(msg => (
+
-      <FeedItem key={msg.id} msg={msg} />
+    return (
-    ))
+      <>
+        {renderSummaryBlock()}
+        {activeMsgs.map(msg => (
+          <FeedItem key={msg.id} msg={msg} activeAgents={activeAgents} onModeChange={handleToolModeChange} collapseHistory={collapseHistory} />
+        ))}
+      </>
+    )
   }
 
   if (!loaded) {
@@ -753,7 +1002,7 @@ export default function Studio({ api }) {
         <div className="studio-feed" ref={feedRef}>
           {renderMessages()}
           {(streaming || streamThinking || loading || streamToolCalls.length > 0) && (
-            <StreamingItem content={streaming} thinking={streamThinking} toolCalls={streamToolCalls} />
+            <StreamingItem content={streaming} thinking={streamThinking} toolCalls={streamToolCalls} segments={streamSegments} activeAgents={activeAgents} onModeChange={handleToolModeChange} collapseHistory={collapseHistory} />
           )}
           <div ref={messagesEnd} style={{ height: '24px' }} />
         </div>
@@ -815,6 +1064,36 @@ export default function Studio({ api }) {
               <rect x="3" y="3" width="18" height="18" rx="2" ry="2"/><circle cx="8.5" cy="8.5" r="1.5"/><polyline points="21 15 16 10 5 21"/>
             </svg>
           </button>
+          <button
+            className="studio-attach-btn"
+            onClick={() => {
+              const next = !advancedReflection
+              setAdvancedReflection(next)
+              try { localStorage.setItem('muyue.advancedReflection', String(next)) } catch {}
+            }}
+            disabled={loading}
+            title={advancedReflection ? "Réflexion avancée: ON (un autre modèle produit un rapport préalable)" : "Réflexion avancée: OFF"}
+            style={advancedReflection ? { color: 'var(--accent, #6c5ce7)', borderColor: 'var(--accent, #6c5ce7)' } : undefined}
+          >
+            <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <circle cx="12" cy="12" r="10"/><path d="M12 6v6l4 2"/>
+            </svg>
+          </button>
+          <button
+            className="studio-attach-btn"
+            onClick={() => {
+              const next = !collapseHistory
+              setCollapseHistory(next)
+              try { localStorage.setItem('muyue.collapseHistory', String(next)) } catch {}
+            }}
+            disabled={loading}
+            title={collapseHistory ? "Historique compressé (dernière action visible)" : "Historique complet (tout visible)"}
+            style={collapseHistory ? { color: 'var(--accent, #6c5ce7)', borderColor: 'var(--accent, #6c5ce7)' } : undefined}
+          >
+            <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+              <line x1="3" y1="6" x2="21" y2="6"/><line x1="3" y1="12" x2="21" y2="12"/><line x1="3" y1="18" x2="21" y2="18"/>
+            </svg>
+          </button>
           <textarea
             ref={textareaRef}
             value={input}

web/src/components/Tests.jsx

@@ -0,0 +1,238 @@
+import { useEffect, useRef, useState, useCallback } from 'react'
+import { TestTube2, Copy, RefreshCw, CheckCircle2, AlertTriangle, Globe, Terminal as TerminalIcon } from 'lucide-react'
+
+export default function Tests({ api }) {
+  const [snippet, setSnippet] = useState(null)
+  const [snippetError, setSnippetError] = useState('')
+  const [sessions, setSessions] = useState([])
+  const [console_, setConsole_] = useState([])
+  const [activeSessionId, setActiveSessionId] = useState('')
+  const [copied, setCopied] = useState(false)
+  const pollRef = useRef(null)
+
+  const refreshSnippet = useCallback(async () => {
+    try {
+      const data = await api.getTestSnippet()
+      setSnippet(data)
+      setSnippetError('')
+    } catch (err) {
+      setSnippetError(err.message || 'Failed to load snippet')
+    }
+  }, [api])
+
+  const refreshSessions = useCallback(async () => {
+    try {
+      const data = await api.getTestSessions()
+      const next = data.sessions || []
+      setSessions(next)
+      if (!activeSessionId && next.length > 0) {
+        setActiveSessionId(next[0].id)
+      } else if (activeSessionId && !next.find(s => s.id === activeSessionId)) {
+        setActiveSessionId(next.length > 0 ? next[0].id : '')
+      }
+    } catch {}
+  }, [api, activeSessionId])
+
+  const refreshConsole = useCallback(async () => {
+    if (!activeSessionId) {
+      setConsole_([])
+      return
+    }
+    try {
+      const data = await api.getTestConsole(activeSessionId)
+      setConsole_(data.console || [])
+    } catch {
+      setConsole_([])
+    }
+  }, [api, activeSessionId])
+
+  useEffect(() => {
+    refreshSnippet()
+  }, [refreshSnippet])
+
+  useEffect(() => {
+    refreshSessions()
+    refreshConsole()
+    pollRef.current = setInterval(() => {
+      refreshSessions()
+      refreshConsole()
+    }, 2000)
+    return () => clearInterval(pollRef.current)
+  }, [refreshSessions, refreshConsole])
+
+  const copySnippet = useCallback(async () => {
+    if (!snippet) return
+    try {
+      await navigator.clipboard.writeText(snippet.snippet)
+      setCopied(true)
+      setTimeout(() => setCopied(false), 1500)
+    } catch {}
+  }, [snippet])
+
+  const activeSession = sessions.find(s => s.id === activeSessionId) || null
+
+  return (
+    <div className="tests-layout" style={{ padding: '20px', display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px', height: '100%', overflow: 'auto' }}>
+      <section className="tests-pane">
+        <header style={{ display: 'flex', alignItems: 'center', gap: 8, marginBottom: 12 }}>
+          <TestTube2 size={18} />
+          <h2 style={{ margin: 0, fontSize: '1.1em' }}>Tests pilotés par l'IA</h2>
+        </header>
+
+        <p style={{ marginTop: 0, opacity: 0.85, lineHeight: 1.5 }}>
+          Donnez à l'IA Studio le contrôle d'un onglet de votre navigateur pour tester chaque bouton et détecter les erreurs console.
+        </p>
+
+        <div style={{ borderTop: '1px solid var(--border, rgba(128,128,128,0.3))', paddingTop: 12, marginTop: 12 }}>
+          <h3 style={{ fontSize: '0.95em', margin: '0 0 8px' }}>1. Connexion</h3>
+          <ol style={{ paddingLeft: 18, lineHeight: 1.6 }}>
+            <li>Ouvrez la page à tester dans n'importe quel navigateur (Chrome, Firefox, Edge…).</li>
+            <li>Ouvrez la console développeur (<kbd>F12</kbd>).</li>
+            <li>Collez ce snippet et appuyez sur <kbd>Entrée</kbd> :</li>
+          </ol>
+
+          {snippetError && (
+            <div style={{ background: 'rgba(220,80,80,0.1)', border: '1px solid rgba(220,80,80,0.3)', padding: 8, borderRadius: 4, marginBottom: 8 }}>
+              {snippetError}
+            </div>
+          )}
+
+          <div style={{ position: 'relative', marginBottom: 12 }}>
+            <pre style={{
+              background: 'var(--bg-secondary, rgba(0,0,0,0.3))',
+              padding: '10px 12px',
+              borderRadius: 4,
+              fontSize: '0.75em',
+              maxHeight: 180,
+              overflow: 'auto',
+              border: '1px solid var(--border, rgba(128,128,128,0.3))',
+              margin: 0,
+            }}>
+{snippet?.snippet || 'Chargement…'}
+            </pre>
+            <button
+              onClick={copySnippet}
+              disabled={!snippet}
+              title="Copier"
+              style={{
+                position: 'absolute', top: 6, right: 6,
+                background: 'var(--bg-tertiary, rgba(255,255,255,0.08))',
+                border: '1px solid var(--border, rgba(128,128,128,0.3))',
+                color: 'inherit', padding: '4px 8px', borderRadius: 3,
+                cursor: 'pointer', fontSize: '0.75em',
+                display: 'flex', alignItems: 'center', gap: 4,
+              }}
+            >
+              <Copy size={11} /> {copied ? 'Copié !' : 'Copier'}
+            </button>
+          </div>
+
+          <button onClick={refreshSnippet} style={{ background: 'transparent', border: '1px solid var(--border, rgba(128,128,128,0.3))', color: 'inherit', padding: '4px 10px', borderRadius: 3, cursor: 'pointer', display: 'inline-flex', alignItems: 'center', gap: 4, fontSize: '0.85em' }}>
+            <RefreshCw size={12} /> Régénérer le token
+          </button>
+          <small style={{ display: 'block', opacity: 0.6, marginTop: 4 }}>
+            Le token expire après {snippet?.expires_in ? Math.round(snippet.expires_in / 60) : 5} minutes ou dès la première connexion.
+          </small>
+        </div>
+
+        <div style={{ borderTop: '1px solid var(--border, rgba(128,128,128,0.3))', paddingTop: 12, marginTop: 16 }}>
+          <h3 style={{ fontSize: '0.95em', margin: '0 0 8px' }}>2. Pilotage par l'IA</h3>
+          <p style={{ margin: '0 0 8px', lineHeight: 1.5 }}>
+            Une fois la session connectée, allez dans l'onglet <strong>Studio</strong> et demandez par exemple :
+          </p>
+          <pre style={{ background: 'var(--bg-secondary, rgba(0,0,0,0.3))', padding: 8, borderRadius: 4, fontSize: '0.85em', margin: 0 }}>
+{`Teste tous les boutons de cette page,
+clique sur chacun, et dis-moi
+lesquels déclenchent une erreur console.`}
+          </pre>
+          <p style={{ margin: '8px 0 0', opacity: 0.75, fontSize: '0.85em' }}>
+            L'IA dispose de l'outil <code>browser_test</code> avec les actions <code>list_clickables</code>, <code>click</code>, <code>console</code>, <code>eval</code>, <code>type</code>, <code>current_url</code>, <code>wait</code>, <code>summary</code>.
+          </p>
+        </div>
+      </section>
+
+      <section className="tests-pane">
+        <header style={{ display: 'flex', alignItems: 'center', gap: 8, marginBottom: 12, justifyContent: 'space-between' }}>
+          <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+            <Globe size={16} />
+            <h2 style={{ margin: 0, fontSize: '1.1em' }}>Sessions connectées</h2>
+          </div>
+          <span style={{ display: 'inline-flex', alignItems: 'center', gap: 4, fontSize: '0.85em' }}>
+            {sessions.length > 0 ? <CheckCircle2 size={14} color="#3aaa61" /> : <span style={{ display: 'inline-block', width: 8, height: 8, borderRadius: '50%', background: '#888' }} />}
+            {sessions.length} session{sessions.length > 1 ? 's' : ''}
+          </span>
+        </header>
+
+        {sessions.length === 0 ? (
+          <div style={{ padding: 16, textAlign: 'center', opacity: 0.7, border: '1px dashed var(--border, rgba(128,128,128,0.3))', borderRadius: 4 }}>
+            <AlertTriangle size={20} style={{ opacity: 0.4 }} />
+            <div style={{ marginTop: 6 }}>Aucune session active.</div>
+            <small>Collez le snippet dans une page pour démarrer.</small>
+          </div>
+        ) : (
+          <div style={{ display: 'flex', flexDirection: 'column', gap: 6, marginBottom: 12 }}>
+            {sessions.map(s => (
+              <button
+                key={s.id}
+                onClick={() => setActiveSessionId(s.id)}
+                style={{
+                  textAlign: 'left',
+                  background: s.id === activeSessionId ? 'var(--accent-bg, rgba(108,92,231,0.15))' : 'transparent',
+                  border: '1px solid ' + (s.id === activeSessionId ? 'var(--accent, #6c5ce7)' : 'var(--border, rgba(128,128,128,0.3))'),
+                  color: 'inherit',
+                  padding: 8, borderRadius: 4, cursor: 'pointer',
+                }}
+              >
+                <div style={{ fontWeight: 500, fontSize: '0.9em', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+                  {s.title || s.url || s.id}
+                </div>
+                <div style={{ fontSize: '0.75em', opacity: 0.65, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
+                  {s.url} · session {s.id.slice(0, 8)}
+                </div>
+              </button>
+            ))}
+          </div>
+        )}
+
+        {activeSession && (
+          <div style={{ borderTop: '1px solid var(--border, rgba(128,128,128,0.3))', paddingTop: 12 }}>
+            <header style={{ display: 'flex', alignItems: 'center', gap: 6, marginBottom: 8 }}>
+              <TerminalIcon size={14} />
+              <h3 style={{ margin: 0, fontSize: '0.95em' }}>Console (live, dernières {console_.length})</h3>
+            </header>
+            <div style={{
+              background: 'var(--bg-secondary, rgba(0,0,0,0.3))',
+              padding: 8,
+              borderRadius: 4,
+              maxHeight: 380,
+              overflow: 'auto',
+              fontSize: '0.8em',
+              fontFamily: 'var(--font-mono, ui-monospace, monospace)',
+              border: '1px solid var(--border, rgba(128,128,128,0.3))',
+            }}>
+              {console_.length === 0 ? (
+                <div style={{ opacity: 0.5 }}>(aucun message console)</div>
+              ) : (
+                console_.map((c, i) => (
+                  <div key={i} style={{ color: levelColor(c.level), padding: '2px 0', borderBottom: '1px dashed rgba(128,128,128,0.15)' }}>
+                    <span style={{ opacity: 0.55, fontSize: '0.85em' }}>[{c.time?.slice(11, 19)} {c.level}]</span> {c.message}
+                  </div>
+                ))
+              )}
+            </div>
+          </div>
+        )}
+      </section>
+    </div>
+  )
+}
+
+function levelColor(lvl) {
+  switch (lvl) {
+    case 'error': return '#ff6b6b'
+    case 'warn': return '#f5a623'
+    case 'info': return '#4dabf7'
+    case 'debug': return '#888'
+    default: return 'inherit'
+  }
+}

web/src/i18n/en.js

@@ -120,6 +120,8 @@ const en = {
     port: 'Port',
     user: 'User',
     keyPath: 'SSH key path',
+    password: 'Password',
+    passwordHint: 'requires sshpass installed',
     connect: 'Connect',
     save: 'Save',
     cancel: 'Cancel',
@@ -209,8 +211,27 @@ const en = {
     resetConfirm: 'Are you sure? All preferences will be erased.',
     resetDone: 'Settings reset.',
     applyStarship: 'Apply starship',
+    apply: 'Apply',
+    remove: 'Remove',
     starshipApplied: 'Starship theme applied! Restart your shell to see the result.',
     starshipError: 'Failed to apply starship theme.',
+    systemConfig: 'System Configuration',
+    aiToolsConfig: 'Tools & Environments',
+    configureViaAI: 'Configure',
+    toolCrushDesc: 'Autonomous AI agent for code writing and refactoring.',
+    toolClaudeDesc: 'AI coding assistant by Anthropic.',
+    toolGhDesc: 'Command-line interface for GitHub.',
+    toolDockerDesc: 'Application containerization platform.',
+    toolGoDesc: 'Programming language and runtime environment.',
+    toolNodeDesc: 'JavaScript runtime and package manager.',
+    toolPythonDesc: 'Programming language, pip and uv manager.',
+    toolStarshipDesc: 'Modern and customizable shell prompt.',
+    systemUpdate: 'System Update',
+    systemUpdateDescSudo: 'Updates the system and all tools (sshpass, crush, claude, gh, etc.).',
+    systemUpdateDescNoSudo: 'Shows update commands to run manually.',
+    updateBtn: 'Update',
+    notInstalled: 'Not installed',
+    install: 'Install',
   },
 }
 

web/src/i18n/fr.js

@@ -120,6 +120,8 @@ const fr = {
     port: 'Port',
     user: 'Utilisateur',
     keyPath: 'Chemin cl\u00e9 SSH',
+    password: 'Mot de passe',
+    passwordHint: 'n\u00e9cessite sshpass install\u00e9',
     connect: 'Se connecter',
     save: 'Enregistrer',
     cancel: 'Annuler',
@@ -209,8 +211,27 @@ const fr = {
     resetConfirm: '\u00cates-vous s\u00fbr ? Toutes les pr\u00e9f\u00e9rences seront effac\u00e9es.',
     resetDone: 'Param\u00e8tres r\u00e9initialis\u00e9s.',
     applyStarship: 'Appliquer starship',
+    apply: 'Appliquer',
+    remove: 'Retirer',
     starshipApplied: 'Th\u00e8me starship appliqu\u00e9 ! Red\u00e9marrez votre shell pour voir le r\u00e9sultat.',
     starshipError: '\u00c9chec de l\u2019application du th\u00e8me starship.',
+    systemConfig: 'Configuration Syst\u00e8me',
+    aiToolsConfig: 'Outils & Environnements',
+    configureViaAI: 'Configurer',
+    toolCrushDesc: 'Agent IA autonome pour l\u2019\u00e9criture et le refactoring de code.',
+    toolClaudeDesc: 'Assistant de codage IA par Anthropic.',
+    toolGhDesc: 'Interface en ligne de commande pour GitHub.',
+    toolDockerDesc: 'Plateforme de conteneurisation d\u2019applications.',
+    toolGoDesc: 'Langage de programmation et environnement d\u2019ex\u00e9cution.',
+    toolNodeDesc: 'Environnement d\u2019ex\u00e9cution JavaScript et gestionnaire de paquets.',
+    toolPythonDesc: 'Langage de programmation, pip et gestionnaire uv.',
+    toolStarshipDesc: 'Prompt shell moderne et personnalisable.',
+    systemUpdate: 'Mise à jour système',
+    systemUpdateDescSudo: 'Met à jour le système et tous les outils (sshpass, crush, claude, gh, etc.).',
+    systemUpdateDescNoSudo: 'Affiche les commandes de mise à jour à exécuter manuellement.',
+    updateBtn: 'Mettre à jour',
+    notInstalled: 'Non installé',
+    install: 'Installer',
   },
 }
 

web/src/styles/global.css

@@ -379,11 +379,11 @@ input::placeholder { color: var(--text-disabled); }
 .shell-menu-item-row { display: flex; align-items: center; }
 .shell-menu-item-icon {
   display: flex; align-items: center; justify-content: center;
-  width: 24px; height: 24px; border-radius: var(--radius);
+  width: 26px; height: 26px; border-radius: var(--radius);
-  background: transparent; border: none; color: var(--text-disabled);
+  background: var(--bg-card); border: 1px solid var(--border); color: var(--text-secondary);
   cursor: pointer; transition: all 0.1s; flex-shrink: 0;
 }
-.shell-menu-item-icon:hover { background: var(--accent-bg); color: var(--accent); }
+.shell-menu-item-icon:hover { background: var(--accent-bg); color: var(--accent); border-color: var(--accent-dim); }
 .shell-menu-empty {
   font-size: 12px; color: var(--text-disabled); padding: 8px 10px;
   font-style: italic;
@@ -442,6 +442,9 @@ input::placeholder { color: var(--text-disabled); }
 
 .shell-ai-col { width: 320px; max-width: 320px; border-left: 1px solid var(--border); background: var(--bg-surface); display: flex; flex-direction: column; flex-shrink: 0; overflow: hidden; }
 .ai-panel-header { padding: 12px 16px; border-bottom: 1px solid var(--border); font-weight: 700; font-size: 13px; color: var(--accent); display: flex; align-items: center; justify-content: space-between; }
+.sudo-indicator { width: 8px; height: 8px; border-radius: 50%; display: inline-block; flex-shrink: 0; }
+.sudo-indicator.sudo-ok { background: #22c55e; box-shadow: 0 0 6px rgba(34, 197, 94, 0.5); }
+.sudo-indicator.sudo-blocked { background: #ef4444; box-shadow: 0 0 6px rgba(239, 68, 68, 0.5); }
 .shell-analyze-btn {
   display: flex; align-items: center; gap: 4px;
   padding: 4px 10px; border-radius: var(--radius);
@@ -456,7 +459,7 @@ input::placeholder { color: var(--text-disabled); }
 .shell-ai-token-fill { height: 100%; background: var(--accent); border-radius: 2px; transition: width 0.4s, background 0.3s; }
 .shell-ai-token-fill.warn { background: var(--warning); }
 .shell-ai-token-text { font-size: 10px; font-family: var(--font-mono); color: var(--text-tertiary); white-space: nowrap; }
-.ai-panel-messages { flex: 1; overflow-y: auto; padding: 12px; display: flex; flex-direction: column; gap: 8px; }
+.ai-panel-messages { flex: 1; overflow-y: auto; padding: 12px; display: flex; flex-direction: column; gap: 8px; scrollbar-width: thin; scrollbar-color: var(--border) transparent; }
 .ai-message { padding: 8px 12px; border-radius: var(--radius); font-size: 13px; line-height: 1.5; word-break: break-word; }
 .ai-message.user { background: var(--bg-elevated); border-left: 3px solid var(--accent-bright); color: var(--text-primary); }
 .ai-message.user.analysis { border-left-color: var(--accent); background: color-mix(in srgb, var(--accent) 10%, var(--bg-elevated)); }
@@ -508,7 +511,7 @@ input::placeholder { color: var(--text-disabled); }
 .shell-mermaid-loading { padding: 16px; text-align: center; color: var(--text-tertiary); font-size: 12px; }
 .shell-mermaid-error { padding: 10px 12px; color: var(--accent-bright); font-family: var(--font-mono); font-size: 12px; white-space: pre-wrap; }
 
-.ai-message table { width: 100%; border-collapse: collapse; margin: 6px 0; font-size: 12px; display: block; overflow-x: auto; }
+.ai-message table { width: 100%; border-collapse: collapse; margin: 6px 0; font-size: 12px; display: block; overflow-x: auto; scrollbar-width: thin; scrollbar-color: var(--border) transparent; }
 .ai-message thead, .ai-message tbody { display: table-row-group; }
 .ai-message th { background: var(--bg-surface); padding: 4px 8px; text-align: left; font-weight: 600; border: 1px solid var(--border); color: var(--text-secondary); white-space: nowrap; }
 .ai-message td { padding: 3px 8px; border: 1px solid var(--border); color: var(--text-primary); white-space: nowrap; }
@@ -1021,8 +1024,10 @@ input::placeholder { color: var(--text-disabled); }
 .feed-content tr:nth-child(even) td { background: var(--bg-surface); }
 .feed-content hr, .ai-message hr { border: none; border-top: 1px solid var(--border); margin: 12px 0; }
 .inline-code { background: var(--bg-input); padding: 2px 6px; border-radius: 4px; font-family: var(--font-mono); font-size: 13px; color: var(--accent-muted); }
-.msg-h3 { font-size: 16px; font-weight: 700; color: var(--text-primary); margin: 10px 0 4px; display: block; }
+.msg-h1 { font-size: 20px; font-weight: 800; color: var(--accent); margin: 16px 0 8px; display: block; }
-.msg-h4 { font-size: 14px; font-weight: 700; color: var(--text-secondary); margin: 8px 0 3px; display: block; }
+.msg-h2 { font-size: 17px; font-weight: 700; color: var(--text-primary); margin: 12px 0 6px; display: block; }
+.msg-h3 { font-size: 15px; font-weight: 700; color: var(--text-primary); margin: 10px 0 4px; display: block; }
+.msg-h4 { font-size: 13px; font-weight: 600; color: var(--text-secondary); margin: 8px 0 3px; display: block; }
 .msg-bullet { display: block; padding-left: 4px; margin: 1px 0; color: var(--text-primary); }
 .msg-step { display: flex; gap: 8px; align-items: baseline; margin: 1px 0; }
 .msg-step-num { color: var(--accent); font-weight: 700; font-family: var(--font-mono); font-size: 13px; flex-shrink: 0; min-width: 20px; }
@@ -1130,6 +1135,22 @@ input::placeholder { color: var(--text-disabled); }
 .feed-collapsed-count { font-size: 10px; color: var(--text-disabled); font-family: var(--font-mono); }
 .feed-expanded-messages { animation: fadeIn 0.2s ease-out; }
 
+.feed-summary-block { margin: 4px 0; }
+.feed-summary-header {
+  display: flex; align-items: center; gap: 10px;
+  padding: 8px 16px;
+  background: var(--bg-surface); border: 1px solid var(--border);
+  border-radius: var(--radius); cursor: pointer;
+  transition: all 0.2s ease;
+}
+.feed-summary-header:hover { background: var(--bg-hover); border-color: var(--accent-dim); }
+.feed-summary-header svg { color: var(--accent); flex-shrink: 0; }
+.feed-summary-text { font-size: 11px; color: var(--text-tertiary); flex: 1; font-weight: 600; }
+.feed-summary-toggle { font-size: 10px; color: var(--accent); font-family: var(--font-mono); }
+
+.skill-list-info { display: flex; flex-direction: column; flex: 1; min-width: 0; }
+.skills-list { display: flex; flex-direction: column; gap: 2px; }
+
 /* ── Studio Tool Blocks ── */
 .studio-tool-block {
   background: var(--bg-surface);
@@ -1291,3 +1312,51 @@ input::placeholder { color: var(--text-disabled); }
 .shell-xterm-instance .xterm-link:hover {
   color: var(--accent-muted) !important;
 }
+
+.config-ai-tools-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+  gap: 10px;
+  margin-bottom: 8px;
+}
+
+.config-ai-tool-card {
+  display: flex;
+  flex-direction: column;
+  padding: 14px;
+  border-radius: var(--radius);
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  transition: border-color 0.15s;
+  min-height: 120px;
+}
+
+.config-ai-tool-card:hover {
+  border-color: var(--accent-dim);
+}
+
+.config-ai-tool-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 8px;
+}
+
+.config-ai-tool-icon {
+  font-size: 18px;
+  line-height: 1;
+}
+
+.config-ai-tool-name {
+  font-weight: 600;
+  font-size: 13px;
+  color: var(--text-primary);
+}
+
+.config-ai-tool-desc {
+  font-size: 11px;
+  color: var(--text-tertiary);
+  line-height: 1.4;
+  margin-bottom: 10px;
+  flex: 1;
+}