Optimiseur : loki tune et bouton « Optimiser », essais sans perte sur un moteur privé

Chercher à la main le bon micro-lot, les threads ou la marge --fit d'un preset
demandait de dupliquer, basculer et comparer des bench complets un par un.
L'optimiseur le fait sur un moteur d'essai, sans jamais toucher à config.env ni
à ce que calcule le modèle, et n'écrit rien sans un clic.

- Isolation : moteur principal arrêté puis relancé ; chaque essai est une copie
  de la configuration (LOKI_HOME/tune/run), lancée par « loki serve » sur
  127.0.0.1 et un port libre, groupe de processus tué en sortie
- Verrou exclusif inter-processus (LOKI_HOME/tune.lock, PID + démarrage +
  binaire) vérifié par serviceAction start/restart et par le chat, les tâches,
  bash_bg, /v1, le bench, la bascule et l'enregistrement de preset, GPU, clé
  d'API, moteur ; essai orphelin arrêté avant tout démarrage du moteur
- Essais : lots, threads, délestage, marges --fit, files CUDA ; placement --fit
  et SPEC/CUDA_GRAPH_OPT/--backend-sampling seulement sur demande
- EXTRA_ARGS jeton par jeton, liste blanche seulement ; ligne de commande de
  chaque essai composée à blanc et comparée à la référence (« dénature »),
  contexte, slots et cache KV recontrôlés une fois chargé
- Mesure : bench complet du lot 1 à profondeur fixe ; score = durée d'un tour
  type (médianes de la télémétrie) ; gain > max(3 %, écart entre passages)
- Application sur clic : copie du preset, ou preset actuel sauvegardé, réécrit
  clé par clé, vérifié par une sonde et rétabli en cas d'échec

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/loki/sys_tune_windows.go

@@ -0,0 +1,78 @@
+//go:build windows
+
+package loki
+
+import (
+	"os/exec"
+	"strconv"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+// Moteur d'essai de l'optimiseur (backend_tune_run.go), côté Windows.
+//
+// L'essai est un « loki serve » qui lance llama-server en ENFANT (execServer) :
+// deux processus. taskkill /T emporte l'arbre entier à partir du PID vérifié,
+// comme svcStop le fait pour le vrai moteur. Pas de console : le processus web
+// tourne souvent en mode application.
+func tuneTrialAttr(cmd *exec.Cmd) {
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		HideWindow:    true,
+		CreationFlags: createNewProcessGroup | createNoWindow,
+	}
+}
+
+// tuneKillTree arrête l'arbre de l'essai. done : voir la version Unix.
+func tuneKillTree(pid int, done <-chan struct{}) {
+	if pid <= 0 {
+		return
+	}
+	_ = hideCmd(exec.Command("taskkill", "/PID", strconv.Itoa(pid), "/T", "/F")).Run()
+	deadline := time.Now().Add(10 * time.Second)
+	for time.Now().Before(deadline) {
+		if done != nil {
+			select {
+			case <-done:
+				return
+			case <-time.After(100 * time.Millisecond):
+			}
+			continue
+		}
+		if !processAlive(pid) {
+			return
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+// procIdentity : heure de création et image d'un processus vivant. Le PID seul
+// ne suffit pas à désigner l'essai orphelin d'un Loki redémarré : Windows
+// recycle vite ses PID, et tuer « le PID noté » pourrait viser n'importe quoi.
+func procIdentity(pid int) (start, exe string, ok bool) {
+	if pid <= 0 || !processAlive(pid) {
+		return "", "", false
+	}
+	const queryLimitedInfo = 0x1000
+	k := syscall.NewLazyDLL("kernel32.dll")
+	h, _, _ := k.NewProc("OpenProcess").Call(queryLimitedInfo, 0, uintptr(pid))
+	if h == 0 {
+		return "", "", false
+	}
+	defer k.NewProc("CloseHandle").Call(h)
+	var creation, exit, kernel, user syscall.Filetime
+	r, _, _ := k.NewProc("GetProcessTimes").Call(h,
+		uintptr(unsafe.Pointer(&creation)), uintptr(unsafe.Pointer(&exit)),
+		uintptr(unsafe.Pointer(&kernel)), uintptr(unsafe.Pointer(&user)))
+	if r == 0 {
+		return "", "", false
+	}
+	start = strconv.FormatInt(creation.Nanoseconds(), 10)
+	buf := make([]uint16, 1024)
+	size := uint32(len(buf))
+	if r, _, _ := k.NewProc("QueryFullProcessImageNameW").Call(h, 0,
+		uintptr(unsafe.Pointer(&buf[0])), uintptr(unsafe.Pointer(&size))); r != 0 {
+		exe = syscall.UTF16ToString(buf[:size])
+	}
+	return start, exe, true
+}