Tâches planifiées : l'IA travaille toute seule (repris de l'amont AJEAN)

Portage des v0.9.9 → v0.10.2 de l'amont, la dernière vraie fonctionnalité qui
nous manquait. Une consigne, une fréquence (« @every 2h », « tous les jours à
9h », ou une expression cron à 5 champs, dans le fuseau du navigateur), et l'IA
l'exécute seule en arrière-plan. Preset épinglé par tâche (bascule de modèle
avant l'exécution, attente du rechargement), accès mémoire et web réglables,
interrupteur maître pour tout suspendre, bouton « tester maintenant ».

Le planificateur est une goroutine, un tic par minute, dans le process qui
détient la conversation et parle au moteur. Une seule tâche part par tic : de
toute façon une seule inférence tourne à la fois, et étaler les départs évite
qu'une rafale monopolise le modèle. Occupé ou modèle en cours de chargement
n'est pas un échec — la tâche repasse au tic suivant.

Une tâche ne partage QU'UN point avec le chat : le verrou de génération. Ni
messages, ni journal d'affichage, ni epoch — elle construit son fil éphémère et
le jette, ne gardant que son texte final comme compte-rendu (borné à 4000
caractères, réinjecté au passage suivant pour la continuité).

Deux adaptations, parce que loki n'est pas l'amont :

— Dossier de travail. Ici il appartient à la DISCUSSION ouverte : une tâche y
  aurait déposé ses fichiers, et en aurait changé en cours de route si
  l'utilisateur changeait de discussion — pour disparaître avec elle à la
  suppression. Chaque tâche a donc le sien (workspace/tasks/<id>/), stable d'un
  passage à l'autre. La bascule ne touche que les points d'entrée des OUTILS
  (agentCwd) : le panneau Fichiers, les dépôts et les liens des messages
  continuent de suivre la discussion de l'utilisateur.

— Capacités. Mem est posé explicitement à MemOff quand l'agent est coupé : le
  zéro de MemMode est la chaîne vide, qu'EnabledTools ne reconnaît pas comme
  « coupée » — une tâche sans agent se serait vu offrir les outils mem_*. Le
  mode code reste off : rôles, critères et passe de vérification n'ont pas de
  sens sans personne en face.

Le refus d'un message pendant qu'une tâche tourne dit maintenant LAQUELLE occupe
le modèle : « génération en cours » sur un fil vide et immobile n'expliquait
rien.

Interface : section repliable dans les réglages (liste, état, prochain passage,
pastille), modale d'édition bâtie sur le gabarit de l'éditeur de preset, panneau
« dernier résultat » en markdown. Vérifié dans un vrai navigateur — création,
rendu, réouverture en édition, bascule intervalle/cron, interrupteur maître,
suppression — sans une seule erreur JS.

internal/loki/chat_conversation.go

@@ -56,6 +56,12 @@ type Conversation struct {
 	Generating bool               `json:"-"`
 	cancel     context.CancelFunc // annule la génération en cours (/stop)
 	epoch      int                // incrémenté à chaque reset → invalide les abonnés
+	// Tâche planifiée en cours (tasks_run.go). Le verrou de génération est le
+	// SEUL point partagé entre une tâche de fond et le chat : ces deux champs
+	// disent à l'interface POURQUOI elle est occupée, au lieu de laisser croire
+	// à une génération fantôme dans la discussion ouverte.
+	runningTaskID   string
+	runningTaskName string
 }
 
 var conv = func() *Conversation {
@@ -286,7 +292,14 @@ func (c *Conversation) state() map[string]any {
 			turns++
 		}
 	}
-	return map[string]any{"seq": c.Seq, "generating": c.Generating, "ctx_used": c.CtxUsed, "turns": turns}
+	st := map[string]any{"seq": c.Seq, "generating": c.Generating, "ctx_used": c.CtxUsed, "turns": turns}
+	// Occupé PAR UNE TÂCHE : l'interface l'annonce (« tâche en cours ») plutôt que
+	// d'afficher un tour qui n'apparaîtra jamais dans le fil.
+	if c.runningTaskID != "" {
+		st["task_id"] = c.runningTaskID
+		st["task_name"] = c.runningTaskName
+	}
+	return st
 }
 
 // isGenerating dit si un tour est en cours. Sert à la LISTE des discussions :
@@ -301,6 +314,20 @@ func (c *Conversation) isGenerating() bool {
 // ErrBusy : une génération est déjà en cours (un seul tour à la fois).
 var ErrBusy = fmt.Errorf("génération en cours")
 
+// busyReason explique le refus à l'utilisateur. Sans ça, un message envoyé
+// pendant qu'une TÂCHE planifiée tourne renvoyait « génération en cours » alors
+// que le fil est vide et que rien ne bouge à l'écran — incompréhensible. On
+// nomme la tâche et on dit comment reprendre la main.
+func (c *Conversation) busyReason() error {
+	c.mu.Lock()
+	name := c.runningTaskName
+	c.mu.Unlock()
+	if name == "" {
+		return ErrBusy
+	}
+	return fmt.Errorf("la tâche planifiée « %s » occupe le modèle — attends la fin ou arrête-la (bouton stop)", name)
+}
+
 // errModelLoading est renvoyée telle quelle à l'utilisateur, dans le chat : ce
 // n'est pas un défaut mais une attente, et le message doit le dire.
 var errModelLoading = fmt.Errorf("⏳ Le modèle est encore en train de charger — réessaie dans quelques secondes.")