Moniteur de Tâches

Surveille les tâches soumises aux clusters SLURM — quantification PTQ, évaluation NEL, déploiement de modèles, ou tâches SLURM brutes.

Quand l'utiliser

1. Auto-surveillance — une autre skill (PTQ, évaluation, déploiement) vient de soumettre une tâche. Enregistrez la tâche et configurez la surveillance immédiatement.
2. Initié par l'utilisateur — l'utilisateur demande le statut d'une tâche. Vérifiez d'abord le registre de la session courante ; si la tâche n'y est pas enregistrée, utilisez les étapes de découverte ci-dessous.

Registre de Tâches

Les tâches actives sont suivies dans des registres par session sous .claude/agents/. Cela évite que plusieurs agents écrasent un registre partagé unique lorsqu'ils s'exécutent simultanément.

Utilisez l'ID de session agent courant comme <session_id> :

• Claude Code : $CLAUDE_CODE_SESSION_ID, ou le champ session_id de l'entrée hook
• Codex : $CODEX_THREAD_ID
• Si aucun ID de session n'est disponible, créez un ID stable pour la session de terminal courante et réutilisez-le pour chaque tâche enregistrée par cet agent

Structure du registre :

.claude/agents/
  <session_id>/
    active_jobs.json

Le fichier active_jobs.json de chaque session est un tableau JSON :

[
  {
    "type": "nel",
    "id": "<invocation_id or slurm_job_id>",
    "host": "<cluster_hostname>",
    "user": "<ssh_user>",
    "submitted": "YYYY-MM-DD HH:MM",
    "description": "<what this job does>",
    "last_status": "<last known status>",
    "owner": {
      "agent": "claude-code|codex|manual",
      "session_id": "<session_id>"
    }
  }
]

type est l'un de : nel, slurm, launcher.

À la Soumission d'une Tâche

Chaque fois qu'une tâche est soumise (par n'importe quelle skill ou manuellement) :

1. Ajoutez une entrée à .claude/agents/<session_id>/active_jobs.json. Créez le répertoire de session et le fichier s'ils n'existent pas.
2. Démarrez un moniteur durable (s'il n'en surveille pas déjà un) qui sonde les tâches enregistrées de cette session jusqu'à ce qu'elles atteignent un état terminal. Préférez l'outil Monitor de Claude Code quand il est disponible : écrivez un petit observateur qui lit .claude/agents/<session_id>/active_jobs.json, vérifie chaque tâche avec la méthode appropriée ci-dessous, affiche les événements de changement d'état, met à jour last_status, supprime les tâches terminales du registre de session, et se termine quand aucune tâche active ne reste pour cette session.

Le moniteur doit se terminer naturellement quand chaque tâche enregistrée a atteint un état terminal. Si l'outil Monitor n'est pas disponible dans le harness courant, exécutez un processus arrière-plan équivalent qui implémente la même boucle et laisse l'agent reprendre/redémarrer quand le processus se termine.

Faites toujours les deux étapes. N'essayez pas de prédire la durée des tâches.

À l'Événement du Moniteur / Vérification de Statut

Qu'il soit déclenché par la sortie du moniteur ou par l'utilisateur demandant « vérifier le statut » :

1. Lisez le registre depuis .claude/agents/<session_id>/active_jobs.json
2. Vérifiez chaque tâche en utilisant la méthode appropriée (voir ci-dessous)
3. Signalez uniquement les changements d'état — comparez contre last_status dans le registre
4. Mettez à jour last_status dans le registre de session
5. Supprimez les tâches terminées — toute tâche dans un état terminal (COMPLETED, FAILED, CANCELLED, KILLED, TIMEOUT, NODE_FAIL, OUT_OF_MEMORY, PREEMPTED, BOOT_FAIL, DEADLINE)
6. S'il ne reste aucune tâche active — laissez le moniteur se terminer

Comment Vérifier Chaque Type de Tâche

Chaque méthode de vérification a sa propre vocabulaire de statut. Un observateur qui les mélange (par exemple qui utilise le regex d'état terminal COMPLETED de SLURM contre la sortie de nel status) ne déclenchera jamais silencieusement les transitions terminales. Faites toujours correspondre le vocabulaire de la source que vous sondez.

Tâches NEL (type: nel)

• Vérifiez : nel status <id>.

extract_nel_state() {
  local jid="$1" nel_bin="${NEL:-nel}" output state_col
  output=$("$nel_bin" status "$jid" 2>&1)
  state_col=$(echo "$output" \
    | awk -F'|' -v prefix="$jid." 'index($1, prefix) == 1 { print $2; exit }')
  [ -z "$state_col" ] && state_col="$output"
  echo "$state_col" \
    | LC_ALL=C tr '[:lower:]' '[:upper:]' \
    | awk 'match($0, /(PENDING|RUNNING|SUCCESS|FAILED|KILLED|ERROR|NOT[[:space:]]+FOUND)/) { print substr($0, RSTART, RLENGTH); exit }' \
    | sed 's/[[:space:]][[:space:]]*/ /g'
}

is_nel_terminal() {
  case "$(extract_nel_state "$1")" in
    SUCCESS|FAILED|KILLED|ERROR|"NOT FOUND") return 0 ;;
    *) return 1 ;;
  esac
}

• À la completion : nel info <id> pour récupérer les résultats.
• En cas d'échec : nel info <id> --logs puis inspectez les logs serveur/client/SLURM via SSH.

Tâches Launcher (type: launcher)

• Vérifiez : Taillez le fichier de sortie arrière-plan du launcher pour les événements clés.
• Événements clés : ID d'expérience, ID de tâche SLURM, import de conteneur, progression d'étalonnage, chemin d'export, statut final.
• En cas d'échec : Cherchez Traceback, Error, ou FAILED dans la sortie.

Tâches SLURM brutes (type: slurm)

• Vérifiez : sacct ; utilisez sacct pour la vérification de terminaison car squeue peut avoir du retard en COMPLETING après que sacct rapporte un état terminal.

extract_slurm_state() {
  local jid="$1" host="$2"
  ssh "$host" "sacct -j $jid -X --format=State --noheader -P 2>/dev/null | head -1" \
    | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' \
    | sed 's/^CANCELLED by .*/CANCELLED/'
}

is_slurm_terminal() {
  case "$(extract_slurm_state "$1" "$2")" in
    COMPLETED|FAILED|CANCELLED|TIMEOUT|NODE_FAIL|OUT_OF_MEMORY|PREEMPTED|BOOT_FAIL|DEADLINE) return 0 ;;
    *) return 1 ;;
  esac
}

• À la completion : ssh <host> "sacct -j <id> --format=State,ExitCode,Elapsed -n".
• En cas d'échec : Vérifiez le fichier journal de sortie de la tâche.

Identifier les Tâches (initié par l'utilisateur, aucun ID donné)

Quand l'utilisateur demande une tâche sans spécifier un ID, vérifiez dans l'ordre :

1. .claude/agents/<current_session_id>/active_jobs.json — tâches de l'agent courant
2. nel ls runs --since 1d — exécutions NEL récentes
3. ssh <host> "squeue -u <user>" — tâches SLURM actives
4. ls -lt tools/launcher/experiments/cicd/ | head -10 — expériences launcher récentes

Directives de Rapport

• Signalez les changements d'état de manière proactive — PENDING → RUNNING, ou tâche complétée
• Agrégez plusieurs tâches — « 2 sur 4 complétées (MMLU-Pro : 42,3 %, GSM8K : 67,1 %), 1 en cours, 1 en attente »
• Résumez, n'écoutez pas en écho — interprétez les événements (« Étalonnage terminé, export du checkpoint ») pas les logs bruts
• En cas d'échec, diagnostiquez immédiatement — vérifiez les logs et signalez la cause racine sans attendre que l'utilisateur demande
• Minimisez le bruit — ne signalez pas « toujours en cours » sauf si l'utilisateur demande activement