Merge pull request 'release: v0.7.4 stable — promote develop to main' (#11) from develop into main

Reviewed-on: #11

.gitea/workflows/ci-develop.yml

@@ -68,6 +68,13 @@ jobs:
           echo "beta_num=${BETA_NUM}" >> $GITHUB_OUTPUT
           echo "Building beta release: ${VERSION}"
 
+      - name: Generate Windows resource (icon)
+        run: |
+          go install github.com/akavel/rsrc@latest
+          RSRC="$(go env GOPATH)/bin/rsrc"
+          $RSRC -ico assets/muyue.ico -arch amd64 -o cmd/muyue/rsrc_windows_amd64.syso
+          $RSRC -ico assets/muyue.ico -arch arm64 -o cmd/muyue/rsrc_windows_arm64.syso
+
       - name: Build (all platforms)
         run: |
           mkdir -p dist

.gitea/workflows/ci-main.yml

@@ -64,6 +64,13 @@ jobs:
           echo "base=${BASE_VERSION}" >> $GITHUB_OUTPUT
           echo "Building stable release: ${VERSION}"
 
+      - name: Generate Windows resource (icon)
+        run: |
+          go install github.com/akavel/rsrc@latest
+          RSRC="$(go env GOPATH)/bin/rsrc"
+          $RSRC -ico assets/muyue.ico -arch amd64 -o cmd/muyue/rsrc_windows_amd64.syso
+          $RSRC -ico assets/muyue.ico -arch arm64 -o cmd/muyue/rsrc_windows_arm64.syso
+
       - name: Build (all platforms)
         run: |
           mkdir -p dist
@@ -138,11 +145,12 @@ jobs:
             echo "sudo mv muyue-darwin-arm64 /usr/local/bin/muyue"
             echo "\`\`\`"
             echo ""
-            echo "**Windows (x86_64)**"
+            echo "**Windows (x86_64)** — sans privilèges admin, crée les raccourcis Bureau + Menu Démarrer :"
             echo "\`\`\`powershell"
-            echo "Invoke-WebRequest -Uri \"${DL_URL}/muyue-windows-amd64.zip\" -OutFile \"muyue.zip\""
-            echo "Expand-Archive -Path \"muyue.zip\" -DestinationPath \".\""
-            echo "Move-Item muyue-windows-amd64.exe C:\\Windows\\muyue.exe"
+            echo "\$dest = \"\$env:LOCALAPPDATA\\Muyue\"; New-Item -ItemType Directory -Force -Path \$dest | Out-Null"
+            echo "Invoke-WebRequest -Uri \"${DL_URL}/muyue-windows-amd64.zip\" -OutFile \"\$env:TEMP\\muyue.zip\""
+            echo "Expand-Archive -Path \"\$env:TEMP\\muyue.zip\" -DestinationPath \$dest -Force"
+            echo "& \"\$dest\\muyue-windows-amd64.exe\" install-shortcuts"
             echo "\`\`\`"
           } > /tmp/stable_changelog.md
           echo "path=/tmp/stable_changelog.md" >> $GITHUB_OUTPUT

.gitignore

@@ -24,6 +24,7 @@ Thumbs.db
 *.exe
 *.test
 *.out
+*.syso
 vendor/
 
 # Config with secrets

CHANGELOG.md

@@ -4,6 +4,157 @@ 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.4
+
+### Logo Muyue intégré
+
+- `LogoMuyue.png` ajouté à la racine + déclinaisons générées dans `assets/` (16/32/64/128/256/512 px) et `assets/muyue.ico` (multi-résolution 16-256 px).
+- **Binaire Windows** : icône embarquée comme ressource Windows via `github.com/akavel/rsrc` au build CI (génération de `cmd/muyue/rsrc_windows_{amd64,arm64}.syso`). Conséquences :
+  - Explorateur Windows affiche l'icône Muyue sur le `.exe`
+  - Les raccourcis créés par `install-shortcuts` héritent de l'icône (via `IconLocation = "$exe,0"`)
+  - Aucune dépendance Go à runtime ; les `.syso` sont gitignorés et regénérés à chaque build
+- **UI web** : favicon réel (16/32 px), apple-touch-icon (256 px) et logo affiché dans le header à côté de "MUYUE".
+- Snippet d'install Windows : 1ʳᵉ ligne idempotente (`New-Item -ItemType Directory -Force`) pour gérer le cas d'une ré-exécution après install partielle.
+- Préservation du logo source en pleine résolution (912×950 RGBA) — pas de perte d'information.
+
+## v0.7.3
+
+### Onboarding — focus MiniMax + MiMo
+
+- L'étape `apikey` du wizard de premier lancement propose désormais **les deux clés** (MiniMax + MiMo) côte à côte ; au moins une doit être validée pour continuer.
+- Les autres fournisseurs (OpenAI, Anthropic, Z.AI, Ollama) ne sont plus proposés dans le wizard — l'utilisateur les configure ensuite via l'onglet **Configuration** s'il le souhaite. Justification : pour les nouveaux utilisateurs, deux choix simples > six choix qui ralentissent le démarrage.
+- Si MiniMax est validé, il devient le provider actif. Sinon, c'est MiMo. Si les deux sont validés, MiniMax reste actif (peut être basculé via `/model change` plus tard).
+
+### Install Windows — pas d'admin + raccourcis automatiques
+
+- **Avant** : la 3ᵉ ligne du snippet d'install (`Move-Item ... C:\Windows\muyue.exe`) échouait avec `UnauthorizedAccessException` sur PowerShell sans élévation.
+- **Maintenant** : 4 lignes, toutes exécutables sans admin :
+  ```powershell
+  $dest = "$env:LOCALAPPDATA\Muyue"
+  Invoke-WebRequest -Uri ".../muyue-windows-amd64.zip" -OutFile "$env:TEMP\muyue.zip"
+  Expand-Archive -Path "$env:TEMP\muyue.zip" -DestinationPath $dest -Force
+  & "$dest\muyue-windows-amd64.exe" install-shortcuts
+  ```
+- Nouvelle commande `muyue install-shortcuts` (Windows uniquement) :
+  - crée `Muyue.lnk` sur le Bureau et dans le Menu Démarrer (résolus via `[Environment]::GetFolderPath`, robuste OneDrive / profils non-standards) ;
+  - utilise WScript.Shell COM via PowerShell pour générer les `.lnk` (pas de dépendance Go ajoutée) ;
+  - ajoute le dossier d'install au `PATH` utilisateur (scope User, pas de modif système).
+- Une icône custom pourra être branchée plus tard en remplaçant la ressource embed du `.exe` ; pour l'instant, l'icône Windows par défaut du binaire est utilisée.
+
+## v0.7.2
+
+### Changes since v0.7.0
+
+- feat(studio): force advanced reflection during browser-test sessions (v0.7.2) (a7d4b31)
+- fix(terminal/windows): fallback to pipes when PTY unsupported (v0.7.1) (fc7a5b9)
+
+### Downloads
+
+| Platform | File |
+|----------|------|
+| Linux x86_64 | [muyue-linux-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.2/muyue-linux-amd64.tar.gz) |
+| Linux ARM64 | [muyue-linux-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.2/muyue-linux-arm64.tar.gz) |
+| macOS Intel | [muyue-darwin-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.2/muyue-darwin-amd64.tar.gz) |
+| macOS Apple Silicon | [muyue-darwin-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.2/muyue-darwin-arm64.tar.gz) |
+| Windows x86_64 | [muyue-windows-amd64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.2/muyue-windows-amd64.zip) |
+| Windows ARM64 | [muyue-windows-arm64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.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.7.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.7.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.7.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.7.2
+
+### Amélioration
+
+- **feat(studio): réflexion avancée forcée automatiquement pendant les tests** — quand au moins une session `browser_test` est connectée, chaque message à Studio active automatiquement la réflexion avancée (un second modèle, si configuré, produit un rapport préalable injecté dans le prompt actif). Le toggle UI est ignoré tant qu'une session de test est active. Justification : pendant un test piloté par l'IA, avoir une analyse complémentaire d'un autre modèle améliore matériellement la qualité des décisions de clic et la couverture du rapport final.
+- Si aucun second provider n'est configuré, le comportement reste silencieux (fallback chat normal — pas d'erreur visible côté utilisateur).
+- Hint UI ajouté dans l'onglet Tests pour expliquer le comportement.
+
+## v0.7.1
+
+### Fix
+
+- **fix(terminal/windows): "unsupported" / connection closed** — `creack/pty` n'a pas de support Windows natif et `pty.Start()` retourne immédiatement une erreur ("operating system not supported"), fermant le WebSocket avant même la bannière. L'utilisateur voyait le menu des terminaux peuplé (détection OK : `wsl --list --quiet` fonctionne) mais chaque clic se soldait par "unsupported" ou une connexion fermée.
+- Introduction de l'abstraction `termSession` (`internal/api/terminal_session.go`) avec deux implémentations sélectionnées au runtime :
+  - **`ptySession`** (Linux / macOS / BSDs) : conserve le comportement existant (TTY complet via `creack/pty`, resize, apps interactives type vim/top).
+  - **`pipeSession`** (Windows) : pipes natifs `stdin` + `stdout` + `stderr` mergés, lus en goroutines, forwardés au WebSocket. Suffisant pour `wsl.exe`, `pwsh`, `cmd` en mode ligne — la plupart des cas d'usage (lancer une commande, voir la sortie, taper la suivante). Resize est un no-op (pas de SIGWINCH sans TTY) ; les TUIs en plein écran ne fonctionnent pas dans ce mode.
+- Refactor minimal de `handleTerminalWS` : utilise `startTermSession(cmd)` au lieu de `pty.Start(cmd)` direct ; même chemin code pour les deux OS.
+
+## v0.7.0
+
+### Changes since v0.4.0
+
+- fix(ci): rename browser_test.go → browsertest.go (6d2f174)
+- feat: AI-driven browser tests — Tests tab + browser_test agent tool (c820d55)
+- release: v0.6.0 — security audit fixes + 7 new features (6a7b4d8)
+- chore: bump version to 0.5.0 (2a6647b)
+- feat: agent concurrency, conversation summaries, AI tools config, UI polish (3740454)
+- feat: AI task API, token-based context windows, SSH password auth, sudo bypass detection (d98110c)
+- feat: agent concurrency, conversation summaries, AI tools config, UI polish (d2bb42b)
+- feat: AI task API, token-based context windows, SSH password auth, sudo bypass detection (e8a289c)
+
+### Downloads
+
+| Platform | File |
+|----------|------|
+| Linux x86_64 | [muyue-linux-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.0/muyue-linux-amd64.tar.gz) |
+| Linux ARM64 | [muyue-linux-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.0/muyue-linux-arm64.tar.gz) |
+| macOS Intel | [muyue-darwin-amd64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.0/muyue-darwin-amd64.tar.gz) |
+| macOS Apple Silicon | [muyue-darwin-arm64.tar.gz](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.0/muyue-darwin-arm64.tar.gz) |
+| Windows x86_64 | [muyue-windows-amd64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.0/muyue-windows-amd64.zip) |
+| Windows ARM64 | [muyue-windows-arm64.zip](https://gitea.legion-muyue.fr/Muyue/MuyueWorkspace/releases/download/v0.7.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.7.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.7.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.7.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.7.0
 
 ### Nouvelle fonctionnalité majeure : Tests pilotés par l'IA

cmd/muyue/commands/install_shortcuts.go

@@ -0,0 +1,151 @@
+package commands
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+
+	"github.com/spf13/cobra"
+)
+
+// installShortcutsCmd creates desktop + Start Menu shortcuts on Windows so
+// non-technical users can launch Muyue without opening a terminal. It also
+// adds the install directory to the user's PATH (per-user, no admin).
+//
+// Implementation note: shortcut (.lnk) creation on Windows is most reliable
+// via WScript.Shell COM. We invoke it via PowerShell — keeps the Go binary
+// dependency-free and works on any Windows 10+ host.
+var installShortcutsCmd = &cobra.Command{
+	Use:   "install-shortcuts",
+	Short: "Create Desktop + Start Menu shortcuts (Windows only) and add Muyue to PATH",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		if runtime.GOOS != "windows" {
+			fmt.Println("install-shortcuts is a Windows-only command (no-op on this platform)")
+			return nil
+		}
+
+		exe, err := os.Executable()
+		if err != nil {
+			return fmt.Errorf("locate executable: %w", err)
+		}
+		exe, _ = filepath.Abs(exe)
+		installDir := filepath.Dir(exe)
+
+		fmt.Println("Installing Muyue shortcuts...")
+		fmt.Printf("  Executable : %s\n", exe)
+
+		desktop, err := userShellFolder("Desktop")
+		if err != nil {
+			return fmt.Errorf("locate Desktop folder: %w", err)
+		}
+		startMenu, err := userShellFolder("Programs")
+		if err != nil {
+			return fmt.Errorf("locate Start Menu Programs folder: %w", err)
+		}
+
+		desktopLnk := filepath.Join(desktop, "Muyue.lnk")
+		startLnk := filepath.Join(startMenu, "Muyue.lnk")
+
+		if err := createWindowsShortcut(desktopLnk, exe, installDir, "Muyue — AI-powered dev environment"); err != nil {
+			return fmt.Errorf("create desktop shortcut: %w", err)
+		}
+		fmt.Printf("  Desktop    : %s\n", desktopLnk)
+
+		if err := createWindowsShortcut(startLnk, exe, installDir, "Muyue — AI-powered dev environment"); err != nil {
+			return fmt.Errorf("create Start Menu shortcut: %w", err)
+		}
+		fmt.Printf("  Start Menu : %s\n", startLnk)
+
+		if err := addUserPATH(installDir); err != nil {
+			fmt.Fprintf(os.Stderr, "  PATH       : warning — could not add %s to user PATH: %v\n", installDir, err)
+		} else {
+			fmt.Printf("  PATH       : added %s (open a new terminal to pick it up)\n", installDir)
+		}
+
+		fmt.Println("\nDone — double-click the Muyue icon on your Desktop to launch.")
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(installShortcutsCmd)
+}
+
+// userShellFolder asks Windows for a user shell folder via PowerShell —
+// resilient to OneDrive redirection and non-default profile locations.
+// `which` is one of: Desktop, Programs (Start Menu Programs), StartMenu.
+func userShellFolder(which string) (string, error) {
+	ps := fmt.Sprintf(`[Environment]::GetFolderPath('%s')`, which)
+	out, err := exec.Command("powershell", "-NoLogo", "-NoProfile", "-Command", ps).Output()
+	if err != nil {
+		return "", err
+	}
+	path := stripTrailingWhitespace(string(out))
+	if path == "" {
+		return "", fmt.Errorf("empty path for %s", which)
+	}
+	return path, nil
+}
+
+func stripTrailingWhitespace(s string) string {
+	for len(s) > 0 && (s[len(s)-1] == '\n' || s[len(s)-1] == '\r' || s[len(s)-1] == ' ' || s[len(s)-1] == '\t') {
+		s = s[:len(s)-1]
+	}
+	return s
+}
+
+// createWindowsShortcut generates a .lnk via WScript.Shell COM. The arguments
+// are passed through PowerShell variables (not interpolated into the script
+// body) to avoid quoting issues with paths containing spaces or special chars.
+func createWindowsShortcut(lnkPath, target, workingDir, description string) error {
+	script := `
+$lnk = $env:MUYUE_LNK
+$target = $env:MUYUE_TARGET
+$workdir = $env:MUYUE_WORKDIR
+$desc = $env:MUYUE_DESC
+$wsh = New-Object -ComObject WScript.Shell
+$sc = $wsh.CreateShortcut($lnk)
+$sc.TargetPath = $target
+$sc.WorkingDirectory = $workdir
+$sc.Description = $desc
+$sc.IconLocation = "$target,0"
+$sc.Save()
+`
+	cmd := exec.Command("powershell", "-NoLogo", "-NoProfile", "-Command", script)
+	cmd.Env = append(os.Environ(),
+		"MUYUE_LNK="+lnkPath,
+		"MUYUE_TARGET="+target,
+		"MUYUE_WORKDIR="+workingDir,
+		"MUYUE_DESC="+description,
+	)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("powershell: %v: %s", err, string(out))
+	}
+	return nil
+}
+
+// addUserPATH appends installDir to the user's PATH if not already present.
+// Uses PowerShell to read/write the User-scope environment via .NET API,
+// which broadcasts WM_SETTINGCHANGE so new processes pick it up.
+func addUserPATH(installDir string) error {
+	script := `
+$dir = $env:MUYUE_INSTALL_DIR
+$current = [Environment]::GetEnvironmentVariable('Path', 'User')
+if ($current -eq $null) { $current = '' }
+$parts = $current -split ';' | Where-Object { $_ -ne '' }
+if ($parts -notcontains $dir) {
+    $new = if ($current -eq '') { $dir } else { "$current;$dir" }
+    [Environment]::SetEnvironmentVariable('Path', $new, 'User')
+}
+`
+	cmd := exec.Command("powershell", "-NoLogo", "-NoProfile", "-Command", script)
+	cmd.Env = append(os.Environ(), "MUYUE_INSTALL_DIR="+installDir)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("powershell: %v: %s", err, string(out))
+	}
+	return nil
+}

internal/api/handlers_chat.go

@@ -213,7 +213,17 @@ func (s *Server) handleChat(w http.ResponseWriter, r *http.Request) {
 	orb.SetSystemPrompt(studioPrompt.String())
 	orb.SetTools(s.agentToolsJSON)
 
-	if body.AdvancedReflection {
+	// Auto-force advanced reflection while a browser-test session is active:
+	// the user is doing AI-driven UI testing, where having a second model
+	// produce a preliminary report (when one is configured) materially
+	// improves which clicks the active model decides to perform. The toggle
+	// remains user-controllable for non-test conversations.
+	wantReflection := body.AdvancedReflection
+	if !wantReflection && s.browserTestStore != nil && len(s.browserTestStore.List()) > 0 {
+		wantReflection = true
+	}
+
+	if wantReflection {
 		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]"
 		}

internal/api/terminal.go

@@ -13,7 +13,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/creack/pty/v2"
 	"github.com/gorilla/websocket"
 	"github.com/muyue/muyue/internal/config"
 )
@@ -154,7 +153,7 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 	}
 	cmd.Env = append(cmd.Env, "TERM=xterm-256color")
 
-	ptmx, err := pty.Start(cmd)
+	session, err := startTermSession(cmd)
 	if err != nil {
 		conn.WriteJSON(wsMessage{Type: "error", Data: err.Error()})
 		return
@@ -163,11 +162,8 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 	var once sync.Once
 	cleanup := func() {
 		once.Do(func() {
-			ptmx.Close()
-			if cmd.Process != nil {
-				cmd.Process.Kill()
-				cmd.Wait()
-			}
+			session.Close()
+			session.Wait()
 		})
 	}
 	defer cleanup()
@@ -175,15 +171,17 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 	go func() {
 		buf := make([]byte, 4096)
 		for {
-			n, err := ptmx.Read(buf)
-			if err != nil {
-				cleanup()
-				return
+			n, err := session.Read(buf)
+			if n > 0 {
+				if err := conn.WriteJSON(wsMessage{
+					Type: "output",
+					Data: string(buf[:n]),
+				}); err != nil {
+					cleanup()
+					return
+				}
 			}
-			if err := conn.WriteJSON(wsMessage{
-				Type: "output",
-				Data: string(buf[:n]),
-			}); err != nil {
+			if err != nil {
 				cleanup()
 				return
 			}
@@ -207,16 +205,13 @@ func (s *Server) handleTerminalWS(w http.ResponseWriter, r *http.Request) {
 
 		switch msg.Type {
 		case "input":
-			if _, err := ptmx.Write([]byte(msg.Data)); err != nil {
+			if _, err := session.Write([]byte(msg.Data)); err != nil {
 				cleanup()
 				return
 			}
 		case "resize":
 			if msg.Rows > 0 && msg.Cols > 0 {
-				pty.Setsize(ptmx, &pty.Winsize{
-					Rows: msg.Rows,
-					Cols: msg.Cols,
-				})
+				session.Resize(msg.Rows, msg.Cols)
 			}
 		}
 	}

internal/api/terminal_session.go

@@ -0,0 +1,198 @@
+package api
+
+// Cross-platform terminal session abstraction.
+//
+// On Linux / macOS we have a real PTY via creack/pty: full TTY semantics,
+// resize support, interactive apps (vim, top…) work. On Windows the same
+// package returns "operating system not supported" at pty.Start time, so we
+// fall back to plain pipes (stdin / stdout merged with stderr). Pipes don't
+// give a real TTY — interactive TUIs misbehave — but `wsl`, `pwsh`, `cmd`,
+// and most CLI tools emit usable line-buffered output, which is what the
+// user actually clicks for.
+
+import (
+	"io"
+	"os"
+	"os/exec"
+	"runtime"
+	"sync"
+
+	"github.com/creack/pty/v2"
+)
+
+// termSession is the read/write/resize/close surface used by handleTerminalWS.
+type termSession interface {
+	Read([]byte) (int, error)
+	Write([]byte) (int, error)
+	Resize(rows, cols uint16) error
+	Close() error
+	Wait() error
+	Pid() int
+}
+
+// startTermSession tries a real PTY first; on Windows or any pty.Start failure
+// it falls back to a pipe-based session.
+func startTermSession(cmd *exec.Cmd) (termSession, error) {
+	if runtime.GOOS != "windows" {
+		ptmx, err := pty.Start(cmd)
+		if err == nil {
+			return &ptySession{ptmx: ptmx, cmd: cmd}, nil
+		}
+		// On unix, a pty.Start error is fatal — pipes won't help interactive
+		// shells without a TTY, and the unix build is the supported path.
+		return nil, err
+	}
+	return startPipeSession(cmd)
+}
+
+// ptySession wraps creack/pty's *os.File-backed PTY.
+type ptySession struct {
+	ptmx *os.File
+	cmd  *exec.Cmd
+}
+
+func (s *ptySession) Read(p []byte) (int, error)  { return s.ptmx.Read(p) }
+func (s *ptySession) Write(p []byte) (int, error) { return s.ptmx.Write(p) }
+func (s *ptySession) Resize(rows, cols uint16) error {
+	return pty.Setsize(s.ptmx, &pty.Winsize{Rows: rows, Cols: cols})
+}
+func (s *ptySession) Close() error {
+	err := s.ptmx.Close()
+	if s.cmd.Process != nil {
+		s.cmd.Process.Kill()
+	}
+	return err
+}
+func (s *ptySession) Wait() error {
+	if s.cmd.Process == nil {
+		return nil
+	}
+	return s.cmd.Wait()
+}
+func (s *ptySession) Pid() int {
+	if s.cmd.Process == nil {
+		return 0
+	}
+	return s.cmd.Process.Pid
+}
+
+// pipeSession is the Windows fallback: stdin pipe + merged stdout/stderr pipe,
+// running concurrently. Resize is a no-op (no TTY to send TIOCSWINSZ to).
+type pipeSession struct {
+	cmd     *exec.Cmd
+	stdin   io.WriteCloser
+	stdout  io.ReadCloser
+	stderr  io.ReadCloser
+	mu      sync.Mutex
+	merged  chan []byte
+	closed  bool
+	closeCh chan struct{}
+}
+
+func startPipeSession(cmd *exec.Cmd) (termSession, error) {
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		return nil, err
+	}
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		stdin.Close()
+		return nil, err
+	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		stdin.Close()
+		stdout.Close()
+		return nil, err
+	}
+	if err := cmd.Start(); err != nil {
+		stdin.Close()
+		stdout.Close()
+		stderr.Close()
+		return nil, err
+	}
+	s := &pipeSession{
+		cmd:     cmd,
+		stdin:   stdin,
+		stdout:  stdout,
+		stderr: stderr,
+		merged:  make(chan []byte, 32),
+		closeCh: make(chan struct{}),
+	}
+	go s.pump(stdout)
+	go s.pump(stderr)
+	return s, nil
+}
+
+func (s *pipeSession) pump(r io.ReadCloser) {
+	buf := make([]byte, 4096)
+	for {
+		n, err := r.Read(buf)
+		if n > 0 {
+			chunk := make([]byte, n)
+			copy(chunk, buf[:n])
+			select {
+			case s.merged <- chunk:
+			case <-s.closeCh:
+				return
+			}
+		}
+		if err != nil {
+			return
+		}
+	}
+}
+
+func (s *pipeSession) Read(p []byte) (int, error) {
+	select {
+	case chunk, ok := <-s.merged:
+		if !ok {
+			return 0, io.EOF
+		}
+		n := copy(p, chunk)
+		return n, nil
+	case <-s.closeCh:
+		return 0, io.EOF
+	}
+}
+
+func (s *pipeSession) Write(p []byte) (int, error) {
+	return s.stdin.Write(p)
+}
+
+func (s *pipeSession) Resize(rows, cols uint16) error {
+	// No real TTY → resize is a no-op; the child won't get SIGWINCH.
+	return nil
+}
+
+func (s *pipeSession) Close() error {
+	s.mu.Lock()
+	if s.closed {
+		s.mu.Unlock()
+		return nil
+	}
+	s.closed = true
+	close(s.closeCh)
+	s.mu.Unlock()
+	s.stdin.Close()
+	s.stdout.Close()
+	s.stderr.Close()
+	if s.cmd.Process != nil {
+		s.cmd.Process.Kill()
+	}
+	return nil
+}
+
+func (s *pipeSession) Wait() error {
+	if s.cmd.Process == nil {
+		return nil
+	}
+	return s.cmd.Wait()
+}
+
+func (s *pipeSession) Pid() int {
+	if s.cmd.Process == nil {
+		return 0
+	}
+	return s.cmd.Process.Pid
+}

internal/version/version.go

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

web/index.html

@@ -4,8 +4,11 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <meta name="theme-color" content="#0A0A0C" />
-  <title>muyue</title>
-  <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>⬡</text></svg>" />
+  <title>Muyue</title>
+  <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32.png" />
+  <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16.png" />
+  <link rel="apple-touch-icon" sizes="180x180" href="/muyue.png" />
+  <link rel="shortcut icon" href="/muyue.png" />
 </head>
 <body>
   <div id="root"></div>

web/src/components/App.jsx

@@ -103,6 +103,7 @@ export default function App() {
     <div className="app-layout">
       <header className="header">
         <div className="header-brand">
+          <img src="/muyue-64.png" alt="Muyue" className="header-logo-img" width="22" height="22" style={{ borderRadius: 4, verticalAlign: 'middle' }} />
           <span className="header-logo">MUYUE</span>
           <span className="header-version">v{info.version || '...'}</span>
         </div>

web/src/components/OnboardingWizard.jsx

@@ -23,8 +23,12 @@ export default function OnboardingWizard({ api, onComplete }) {
     language: 'fr',
     keyboard: 'azerty',
     apikey: '',
+    apikey_mimo: '',
     editor: '',
   })
+  const [keyValidMimo, setKeyValidMimo] = useState(false)
+  const [errorMimo, setErrorMimo] = useState(null)
+  const [validatingMimo, setValidatingMimo] = useState(false)
   const [editorList, setEditorList] = useState(BASE_EDITORS)
   const [saving, setSaving] = useState(false)
   const [error, setError] = useState(null)
@@ -52,7 +56,7 @@ export default function OnboardingWizard({ api, onComplete }) {
       case 'name': return answers.name.trim().length > 0
       case 'language': return !!answers.language
       case 'keyboard': return !!answers.keyboard
-      case 'apikey': return keyValid && !scanning
+      case 'apikey': return (keyValid || keyValidMimo) && !scanning
       case 'editor': return true
       case 'done': return true
       default: return true
@@ -173,6 +177,33 @@ export default function OnboardingWizard({ api, onComplete }) {
     setValidating(false)
   }
 
+  const handleValidateKeyMimo = async () => {
+    if (!answers.apikey_mimo.trim()) return
+    setValidatingMimo(true)
+    setErrorMimo(null)
+    try {
+      await api.validateProvider({
+        name: 'mimo',
+        api_key: answers.apikey_mimo,
+        model: 'mimo-v2.5-pro',
+        base_url: 'https://token-plan-ams.xiaomimimo.com/v1',
+      })
+      setKeyValidMimo(true)
+      // Save MiMo. If MiniMax wasn't validated yet, MiMo becomes the active provider.
+      await api.saveProvider({
+        name: 'mimo',
+        api_key: answers.apikey_mimo,
+        model: 'mimo-v2.5-pro',
+        base_url: 'https://token-plan-ams.xiaomimimo.com/v1',
+        active: !keyValid,
+      })
+    } catch (err) {
+      setErrorMimo(err.message || 'Clé invalide')
+      setKeyValidMimo(false)
+    }
+    setValidatingMimo(false)
+  }
+
 
 
   const handleSave = async () => {
@@ -201,6 +232,15 @@ export default function OnboardingWizard({ api, onComplete }) {
           active: true,
         })
       }
+      if (answers.apikey_mimo.trim()) {
+        await api.saveProvider({
+          name: 'mimo',
+          api_key: answers.apikey_mimo,
+          model: 'mimo-v2.5-pro',
+          base_url: 'https://token-plan-ams.xiaomimimo.com/v1',
+          active: !answers.apikey.trim(),
+        })
+      }
       onComplete()
     } catch (err) {
       setError(err.message || 'Erreur lors de la sauvegarde')
@@ -283,38 +323,71 @@ export default function OnboardingWizard({ api, onComplete }) {
 
           {current.key === 'apikey' && (
             <div className="onboarding-step">
-              <div className="onboarding-title">Clé API MiniMax</div>
+              <div className="onboarding-title">Clés API</div>
               <div className="onboarding-desc">
-                Entrez votre clé API MiniMax pour activer l'assistant IA. La clé est obligatoire pour continuer.
+                Renseignez au moins l'une des deux clés pour activer l'assistant. Les autres fournisseurs (OpenAI, Anthropic, Ollama, Z.AI) se configurent plus tard depuis l'onglet Configuration.
               </div>
-              <input
-                className="onboarding-input"
-                placeholder="sk-xxxxxxxxxxxxxxxx"
-                type="password"
-                value={answers.apikey}
-                onChange={e => { setAnswers(a => ({ ...a, apikey: e.target.value })); setKeyValid(false); setError(null) }}
-                autoFocus
-              />
-              {error && !keyValid && <div className="onboarding-required">{error}</div>}
-              {keyValid && !scanning && <div className="onboarding-valid">Clé valide ✓ — Appuyez sur Entrée pour continuer</div>}
+
+              <div style={{ display: 'flex', flexDirection: 'column', gap: 6, marginTop: 4 }}>
+                <label style={{ fontSize: 12, color: 'var(--text-tertiary)', fontWeight: 600 }}>MiniMax</label>
+                <input
+                  className="onboarding-input"
+                  placeholder="sk-xxxxxxxxxxxxxxxx (MiniMax)"
+                  type="password"
+                  value={answers.apikey}
+                  onChange={e => { setAnswers(a => ({ ...a, apikey: e.target.value })); setKeyValid(false); setError(null) }}
+                  autoFocus
+                />
+                <div style={{ display: 'flex', gap: 8, alignItems: 'center', flexWrap: 'wrap' }}>
+                  <button
+                    className="sm primary"
+                    onClick={handleValidateKey}
+                    disabled={validating || !answers.apikey.trim()}
+                  >
+                    {validating ? 'Validation...' : 'Valider MiniMax'}
+                  </button>
+                  {keyValid && <span className="onboarding-valid">✓ MiniMax OK</span>}
+                  {error && !keyValid && <span className="onboarding-required">{error}</span>}
+                </div>
+              </div>
+
+              <div style={{ display: 'flex', flexDirection: 'column', gap: 6, marginTop: 12 }}>
+                <label style={{ fontSize: 12, color: 'var(--text-tertiary)', fontWeight: 600 }}>MiMo (Xiaomi)</label>
+                <input
+                  className="onboarding-input"
+                  placeholder="sk-xxxxxxxxxxxxxxxx (MiMo)"
+                  type="password"
+                  value={answers.apikey_mimo}
+                  onChange={e => { setAnswers(a => ({ ...a, apikey_mimo: e.target.value })); setKeyValidMimo(false); setErrorMimo(null) }}
+                />
+                <div style={{ display: 'flex', gap: 8, alignItems: 'center', flexWrap: 'wrap' }}>
+                  <button
+                    className="sm primary"
+                    onClick={handleValidateKeyMimo}
+                    disabled={validatingMimo || !answers.apikey_mimo.trim()}
+                  >
+                    {validatingMimo ? 'Validation...' : 'Valider MiMo'}
+                  </button>
+                  {keyValidMimo && <span className="onboarding-valid">✓ MiMo OK</span>}
+                  {errorMimo && !keyValidMimo && <span className="onboarding-required">{errorMimo}</span>}
+                </div>
+              </div>
+
               {scanning && (
-                <div className="onboarding-scanning">
+                <div className="onboarding-scanning" style={{ marginTop: 8 }}>
                   <Loader size={14} className="spin-icon" />
                   <span>{scanMessage}</span>
                 </div>
               )}
-              {requiredError && <div className="onboarding-required">Veuillez valider votre clé API pour continuer</div>}
-              <div style={{ display: 'flex', gap: 8, marginTop: 4 }}>
-                <button
-                  className="sm primary"
-                  onClick={handleValidateKey}
-                  disabled={validating || !answers.apikey.trim()}
-                >
-                  {validating ? 'Validation...' : 'Valider la clé'}
-                </button>
-              </div>
-              {!keyValid && !error && answers.apikey.trim() && (
-                <div className="onboarding-hint">Entrez votre clé puis cliquez "Valider la clé"</div>
+              {requiredError && (
+                <div className="onboarding-required" style={{ marginTop: 8 }}>
+                  Veuillez valider au moins une clé (MiniMax ou MiMo) pour continuer.
+                </div>
+              )}
+              {(keyValid || keyValidMimo) && !scanning && (
+                <div className="onboarding-valid" style={{ marginTop: 8 }}>
+                  Au moins une clé est valide — appuyez sur Suivant pour continuer.
+                </div>
               )}
             </div>
           )}

web/src/components/Tests.jsx

@@ -148,6 +148,9 @@ lesquels déclenchent une erreur console.`}
           <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>
+          <p style={{ margin: '8px 0 0', padding: 8, fontSize: '0.85em', background: 'var(--accent-bg, rgba(108,92,231,0.1))', border: '1px solid var(--accent, #6c5ce7)', borderRadius: 4 }}>
+            <strong>Réflexion avancée auto :</strong> tant qu'au moins une session de test est connectée, chaque message dans Studio utilise automatiquement la réflexion avancée — un second modèle (s'il est configuré) produit un rapport d'analyse préalable injecté dans le prompt actif. Le toggle Studio est ignoré pendant la session.
+          </p>
         </div>
       </section>