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/tasks.go

@@ -0,0 +1,102 @@
+package loki
+
+// tasks.go — les tâches planifiées : des consignes que l'IA exécute toute seule,
+// en arrière-plan, sur une fréquence réglable (intervalle simple ou cron). Chaque
+// tâche tourne ISOLÉE de la conversation partagée (voir RunAutonomous dans
+// tasks_run.go) : elle ne pollue pas le chat et livre son résultat via les propres
+// outils de l'IA (mail via MCP, shell, web…). L'utilisateur peut désactiver une
+// tâche, ou tout suspendre d'un coup via l'interrupteur maître (tasks_paused).
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"sort"
+	"time"
+
+	bolt "go.etcd.io/bbolt"
+)
+
+// Task est une tâche planifiée persistée dans le bucket bkTasks (clé = ID).
+type Task struct {
+	ID       string `json:"id"`
+	Name     string `json:"name"`
+	Prompt   string `json:"prompt"`
+	Schedule string `json:"schedule"` // "@every 2h" | "@every 1d@23:00" | expr cron 5 champs
+	TZ       string `json:"tz"`       // fuseau IANA du navigateur (ex. "Europe/Paris") pour l'heure
+	Preset   string `json:"preset"`   // id du preset à activer avant l'exécution (vide = preset actif)
+	// Accès de la tâche. On stocke la NÉGATION (« pas de… ») pour que le zéro JSON
+	// (tâches créées avant ces champs) garde le comportement historique : accès.
+	NoMem      bool   `json:"no_mem"` // true = pas d'accès à la mémoire pour cette tâche
+	NoWeb      bool   `json:"no_web"` // true = pas d'accès au web pour cette tâche
+	Enabled    bool   `json:"enabled"`
+	LastRun    int64  `json:"last_run"`    // epoch ms, 0 = jamais
+	NextRun    int64  `json:"next_run"`    // epoch ms, 0 = à (re)calculer
+	LastDurMs  int64  `json:"last_dur_ms"` // durée du dernier passage en ms
+	LastOK     bool   `json:"last_ok"`
+	LastError  string `json:"last_error"`
+	LastReport string `json:"last_report"` // dernier texte final de l'IA (compte-rendu court)
+
+	Running bool `json:"-"` // transitoire : une exécution est en cours
+}
+
+// newTaskID génère un identifiant court et unique.
+func newTaskID() string {
+	var b [6]byte
+	_, _ = rand.Read(b[:])
+	return hex.EncodeToString(b[:])
+}
+
+// listTasks renvoie toutes les tâches, triées par nom pour un affichage stable.
+func listTasks() []Task {
+	var out []Task
+	_ = view(bkTasks, func(b *bolt.Bucket) error {
+		return b.ForEach(func(_, v []byte) error {
+			var t Task
+			if json.Unmarshal(v, &t) == nil {
+				out = append(out, t)
+			}
+			return nil
+		})
+	})
+	sort.Slice(out, func(i, j int) bool {
+		if out[i].Name != out[j].Name {
+			return out[i].Name < out[j].Name
+		}
+		return out[i].ID < out[j].ID
+	})
+	return out
+}
+
+// getTask lit une tâche par ID. Renvoie false si absente.
+func getTask(id string) (Task, bool) {
+	var t Task
+	ok := getJSON(bkTasks, id, &t)
+	return t, ok
+}
+
+// saveTask enregistre (crée ou remplace) une tâche.
+func saveTask(t Task) error { return putJSON(bkTasks, t.ID, t) }
+
+// deleteTask supprime une tâche par ID.
+func deleteTask(id string) error { return putBytes(bkTasks, id, nil) }
+
+// tasksPaused indique si l'interrupteur maître suspend TOUTES les tâches. On
+// stocke « en pause » plutôt que « actif » pour que l'état par défaut (base
+// neuve) soit « actif » sans dépendre d'une écriture : c'est un frein, pas un
+// moteur.
+func tasksPaused() bool { return getBool(bkState, "tasks_paused") }
+
+func setTasksPaused(on bool) error { return putBool(bkState, "tasks_paused", on) }
+
+// computeNextRun calcule le prochain déclenchement d'une tâche à partir de son
+// Schedule (dans le fuseau tz), relatif à `from`. Renvoie 0 si le schedule est
+// invalide (la tâche ne se déclenchera alors jamais — l'UI refuse déjà un
+// schedule invalide à la sauvegarde, ceci n'est qu'un garde-fou).
+func computeNextRun(schedule, tz string, from time.Time) int64 {
+	next, err := nextAfter(schedule, tz, from)
+	if err != nil {
+		return 0
+	}
+	return next.UnixMilli()
+}