cancel

Compétence Cancel

Annulation intelligente qui détecte et annule le mode OMC actif.

La compétence cancel est la méthode standard pour terminer et quitter tout mode OMC. Lorsque le hook d'arrêt détecte que le travail est terminé, il demande au LLM d'invoquer cette compétence pour un nettoyage d'état approprié. Si cancel échoue ou est interrompu, réeessayez avec le drapeau --force, ou attendez le timeout de péremption de 2 heures en dernier recours.

Ce qu'elle fait

Détecte automatiquement quel mode est actif et l'annule :

• Autopilot : Arrête le workflow, conserve la progression pour une reprise
• Ralph : Arrête la boucle de persistance
• État Ultrawork hérité : Suppression uniquement pour nettoyage des installations mises à niveau ; ce n'est pas un workflow actif
• UltraQA (retiré) : Aucun workflow actif ne reste ; efface le fichier ultraqa-state.json obsolète pré-5.0.0 s'il est présent
• Ultragoal : Efface la garde d'exécution ultragoal liée à la session (.omc/state/.../ultragoal-state.json) afin que l'application de PreToolUse /goal et le renforcement Stop soient relâchés. Les artefacts durables .omc/ultragoal/ (plan/registre) sont préservés.
• Swarm : Arrête l'essaim d'agents coordonné, libère les tâches revendiquées
• Ultrapilot : Arrête les workers autopilot parallèles
• Pipeline : Arrête le pipeline d'agents séquentiel
• Team : Demande l'arrêt à tous les coéquipiers via la surface de conversation/équipe active, attend les réponses/timeouts, efface l'état OMC de l'équipe, efface ralph lié s'il est présent. Claude Code 2.1.178+ n'a pas TeamDelete.
• Team+Ralph (lié) : Annule d'abord l'équipe (arrêt gracieux), puis efface l'état ralph. Annuler ralph quand il est lié annule également l'équipe d'abord.

Utilisation

/oh-my-claudecode:cancel

Ou dites : "cancelomc", "stopomc"

Critique : Gestion des outils différés

Les outils de gestion d'état (state_clear, state_read, state_write, state_list_active, state_get_status) peuvent être enregistrés comme outils différés par Claude Code. Avant d'appeler un outil d'état, vous DEVEZ d'abord tous les charger via ToolSearch :

ToolSearch(query="select:mcp__plugin_oh-my-claudecode_t__state_clear,mcp__plugin_oh-my-claudecode_t__state_read,mcp__plugin_oh-my-claudecode_t__state_write,mcp__plugin_oh-my-claudecode_t__state_list_active,mcp__plugin_oh-my-claudecode_t__state_get_status")

Si state_clear est indisponible ou échoue, utilisez ce repli bash comme issue d'urgence de la boucle du hook d'arrêt. Ce n'est PAS un remplacement complet du flux cancel — il supprime seulement les fichiers d'état pour débloquer la session. Les modes actifs liés (par exemple, autopilot→ralph) doivent être effacés séparément en exécutant le repli une fois par mode.

Remplacez MODE par le mode spécifique (par ex. ralplan, ralph, ultrawork, ultragoal).

ATTENTION : N'utilisez PAS ce repli pour autopilot ou omc-teams. Autopilot nécessite state_write(active=false) pour préserver les données de reprise. omc-teams nécessite un nettoyage de session tmux qui ne peut pas être effectué par simple suppression de fichier.

# Repli : suppression directe de fichier lorsque l'outil MCP state_clear est indisponible
SESSION_ID="${CLAUDE_SESSION_ID:-${CLAUDECODE_SESSION_ID:-}}"
REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || { d="$PWD"; while [ "$d" != "/" ] && [ ! -d "$d/.omc" ]; do d="$(dirname "$d")"; done; echo "$d"; })"

# SHA-256 multiplateforme (macOS : shasum, Linux : sha256sum)
sha256portable() { printf '%s' "$1" | (sha256sum 2>/dev/null || shasum -a 256) | cut -c1-16; }

# Résolution du répertoire d'état (prend en charge le stockage centralisé OMC_STATE_DIR)
if [ -n "${OMC_STATE_DIR:-}" ]; then
  # Miroir de getProjectIdentifier() depuis worktree-paths.ts
  SOURCE="$(git remote get-url origin 2>/dev/null || echo "$REPO_ROOT")"
  HASH="$(sha256portable "$SOURCE")"
  DIR_NAME="$(basename "$REPO_ROOT" | sed 's/[^a-zA-Z0-9_-]/_/g')"
  OMC_STATE="$OMC_STATE_DIR/${DIR_NAME}-${HASH}/state"
  [ ! -d "$OMC_STATE" ] && { echo "ERREUR : Répertoire d'état introuvable à $OMC_STATE" >&2; exit 1; }
elif [ "$REPO_ROOT" != "/" ] && [ -d "$REPO_ROOT/.omc" ]; then
  OMC_STATE="$REPO_ROOT/.omc/state"
else
  echo "ERREUR : Impossible de localiser le répertoire d'état .omc" >&2
  exit 1
fi
MODE="ralplan"  # <-- remplacez par le mode cible

# Efface l'état lié à la session pour le mode spécifique
if [ -n "$SESSION_ID" ] && [ -d "$OMC_STATE/sessions/$SESSION_ID" ]; then
  rm -f "$OMC_STATE/sessions/$SESSION_ID/${MODE}-state.json"
  rm -f "$OMC_STATE/sessions/$SESSION_ID/${MODE}-stop-breaker.json"
  rm -f "$OMC_STATE/sessions/$SESSION_ID/skill-active-state.json"
  # Écrit le signal d'annulation pour que le hook d'arrêt détecte l'annulation en cours
  NOW_ISO="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
  EXPIRES_ISO="$(date -u -d "+30 seconds" +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || python3 - <<'PY'\nfrom datetime import datetime, timedelta, timezone\nprint((datetime.now(timezone.utc) + timedelta(seconds=30)).strftime('%Y-%m-%dT%H:%M:%SZ'))\nPY\n)"
  printf '{"active":true,"requested_at":"%s","expires_at":"%s","mode":"%s","source":"bash_fallback"}' \
    "$NOW_ISO" "$EXPIRES_ISO" "$MODE" > "$OMC_STATE/sessions/$SESSION_ID/cancel-signal-state.json"
fi

# Efface l'état hérité seulement s'il n'y a pas d'ID de session (évite d'effacer l'état d'une autre session)
if [ -z "$SESSION_ID" ]; then
  rm -f "$OMC_STATE/${MODE}-state.json"
fi

Auto-détection

/oh-my-claudecode:cancel suit le contrat d'état sensible à la session :

• Par défaut, la commande inspecte la session courante via state_list_active et state_get_status, en naviguant dans .omc/state/sessions/{sessionId}/… pour découvrir quel mode est actif.
• Lorsqu'un identifiant de session est fourni ou déjà connu, ce chemin lié à la session est faisant autorité. Les fichiers hérités dans .omc/state/*.json ne sont consultés que comme repli de compatibilité si l'identifiant de session est manquant ou vide.
• Swarm est un mode partagé SQLite/marqueur (.omc/state/swarm.db / .omc/state/swarm-active.marker) et n'est pas lié à une session.
• Le flux de nettoyage par défaut appelle state_clear avec l'identifiant de session pour supprimer uniquement les fichiers de session correspondants ; les modes restent liés à leur session d'origine.

Les modes actifs sont toujours annulés dans l'ordre de dépendance :

1. Autopilot (inclut ralph lié et nettoyage d'état retiré)
2. Ralph
3. Nettoyage d'état Ultrawork/UltraQA hérité
4. Ultragoal (garde d'exécution autonome — state_clear(mode="ultragoal") ; préserve les artefacts .omc/ultragoal/ durables)
5. Swarm (autonome)
6. Ultrapilot (autonome)
7. Pipeline (autonome)
8. Team (Claude Code natif)
9. Équipes OMC (workers CLI tmux)
10. Plan Consensus (autonome)
11. Self-Improve (autonome — efface l'état, nettoie les worktrees orphelins, préserve iteration_state pour la reprise, définit le statut : "user_stopped" dans le fichier <self-improve-root>/state/agent-settings.json résolu ; les nouvelles exécutions utilisent .omc/self-improve/topics/<topic-slug>/, avec .omc/self-improve/ plat conservé uniquement pour les reprises historique mono-piste)

Forcer l'effacement total

Utilisez --force ou --all lorsque vous devez effacer chaque session ainsi que les artefacts hérités, par exemple pour réinitialiser complètement l'espace de travail.

/oh-my-claudecode:cancel --force

/oh-my-claudecode:cancel --all

Étapes sous le capot :

1. state_list_active énumère .omc/state/sessions/{sessionId}/… pour trouver chaque session connue.
2. state_clear s'exécute une fois par session pour supprimer les fichiers de cette session.
3. Un state_clear global sans session_id supprime les fichiers hérités sous .omc/state/*.json, .omc/state/swarm*.db et les artefacts de compatibilité (voir liste).
4. Les artefacts d'équipe (~/.claude/teams/*/, ~/.claude/tasks/*/, .omc/state/team-state.json) sont effacés au mieux dans le cadre du repli hérité.
   • L'annulation pour une équipe native N'affecte PAS l'état des équipes OMC, et vice versa.

Chaque commande state_clear respecte l'argument session_id, donc même le mode force utilise d'abord les chemins sensibles à la session avant de supprimer les fichiers hérités.

Liste de compatibilité héritée (supprimée uniquement avec --force/--all) :

• .omc/state/autopilot-state.json
• .omc/state/ralph-state.json
• .omc/state/ralph-plan-state.json
• .omc/state/ralph-verification.json
• .omc/state/ultrawork-state.json
• .omc/state/ultraqa-state.json
• .omc/state/swarm.db
• .omc/state/swarm.db-wal
• .omc/state/swarm.db-shm
• .omc/state/swarm-active.marker
• .omc/state/swarm-tasks.db
• .omc/state/ultrapilot-state.json
• .omc/state/ultrapilot-ownership.json
• .omc/state/pipeline-state.json
• .omc/state/omc-teams-state.json
• .omc/state/plan-consensus.json
• .omc/state/ralplan-state.json
• .omc/state/boulder.json
• .omc/state/hud-state.json
• .omc/state/subagent-tracking.json
• .omc/state/subagent-tracker.lock
• .omc/state/rate-limit-daemon.pid
• .omc/state/rate-limit-daemon.log
• .omc/state/checkpoints/ (répertoire)
• .omc/state/sessions/ (nettoyage du répertoire vide après avoir effacé les sessions)

Étapes d'implémentation

Lorsque vous invoquez cette compétence :

1. Analyser les arguments

# Vérifie la présence des drapeaux --force ou --all
FORCE_MODE=false
if [[ "$*" == *"--force"* ]] || [[ "$*" == *"--all"* ]]; then
  FORCE_MODE=true
fi

2. Détecter les modes actifs

La compétence repose désormais sur le contrat d'état sensible à la session plutôt que sur des chemins de fichiers codés en dur :

1. Appelez state_list_active pour énumérer .omc/state/sessions/{sessionId}/… et découvrir chaque session active.
2. Pour chaque identifiant de session, appelez state_get_status pour savoir quel mode actif est en cours d'exécution et si des modes dépendants existent ; traitez tout enregistrement Ultrawork comme une entrée de nettoyage retirée uniquement.
3. Si un session_id a été fourni à /oh-my-claudecode:cancel, ignorez entièrement le repli hérité et opérez uniquement dans ce chemin de session ; sinon, consultez les fichiers hérités dans .omc/state/*.json uniquement si les outils d'état ne signalent aucune session active. Swarm reste un mode partagé SQLite/marqueur en dehors du cadre de session.
4. Toute logique d'annulation dans ce document reflète l'ordre de dépendance découvert via les outils d'état (autopilot → ralph → …).

3A. Mode Force (si --force ou --all)

Utilisez le mode force pour effacer chaque session ainsi que les artefacts hérités via state_clear. La suppression directe de fichier est réservée au nettoyage hérité lorsque les outils d'état ne signalent aucune session active.

3B. Annulation intelligente (par défaut)

Si l'équipe est active (équipe implicite Claude Code)

Les équipes sont détectées via l'état OMC de l'équipe, et non les répertoires de configuration Claude Code ~/.claude/teams supprimés :

# Vérifier la présence d'un état OMC d'équipe actif
state_read(mode="team")

Protocole d'annulation en deux passes :

Passe 1 : Arrêt gracieux

Pour l'état OMC d'équipe actif :
  1. Lire team_name et les étiquettes des workers depuis l'état OMC/les handoffs/la comptabilité des tâches
  2. Pour chaque coéquipier actif :
     a. Demander ou notifier le coéquipier nommé via la surface de messagerie/conversation d'équipe active
     b. Attendre jusqu'à 15 secondes une shutdown_response
     c. Si une réponse est reçue : marquer le membre comme ayant accusé réception
     d. Si timeout : marquer le membre comme ne répondant pas, passer au suivant
  3. Journaliser : "Passe gracieuse : X/Y membres ont répondu"

Passe 2 : Réconciliation

Après la passe gracieuse :
  1. Attendre 5 secondes supplémentaires pour les coéquipiers ne répondant pas qui pourraient encore être en traitement
  2. Enregistrer tous les coéquipiers ne répondant pas restants dans le rapport d'annulation
  3. Ne pas appeler TeamDelete ; Claude Code 2.1.178+ a supprimé le nettoyage natif par équipe

Nettoyage de l'état OMC :

  1. Effacer l'état de l'équipe : state_clear(mode="team")
  2. Vérifier la présence de ralph lié : state_read(mode="ralph") — si linked_team est true :
     a. Effacer l'état ralph : state_clear(mode="ralph")
  3. Exécuter une analyse des orphelins OMC tmux/CLI uniquement pour les workers hérités `omc team` / `/omc-teams` (voir ci-dessous)
  4. Émettre un rapport d'annulation structuré

Détection des orphelins (post-nettoyage) :

Pour les exécutions héritées de workers OMC tmux/CLI, vérifiez qu'aucun processus worker ne subsiste :

node "${CLAUDE_PLUGIN_ROOT}/scripts/cleanup-orphans.mjs" --team-name "{team_name}"

L'analyseur d'orphelins :

1. Vérifie ps aux (Unix) ou tasklist (Windows) pour les processus workers OMC avec --team-name correspondant à l'équipe nettoyée
2. Envoie SIGTERM, attend 5s, envoie SIGKILL si toujours actif
3. Rapporte les résultats du nettoyage au format JSON

Utilisez --dry-run pour inspecter sans tuer. L'analyseur peut être exécuté plusieurs fois en toute sécurité.

Rapport d'annulation structuré :

Équipe "{team_name}" annulée :
  - Membres signalés : N
  - Réponses reçues : M
  - Ne répondant pas : K (liste des noms si présents)
  - État OMC effacé : oui/non
  - Nettoyage manuel nécessaire : oui/non
    Chemin : état OMC de l'équipe / processus workers tmux, le cas échéant

Note d'implémentation : La compétence cancel est exécutée par le LLM, pas comme un script bash. Lorsque vous détectez une équipe active :

1. Lisez state_read(mode="team") pour trouver l'équipe OMC active
2. Identifiez les coéquipiers nommés actifs depuis l'état, les handoffs, ou la comptabilité des tâches
3. Pour chaque coéquipier, demandez ou notifiez le coéquipier nommé via la surface de messagerie/conversation d'équipe active
4. Attendez brièvement les réponses d'arrêt (timeout de 15s par membre)
5. Enregistrez les coéquipiers ne répondant pas après une attente de réconciliation
6. Effacez l'état de l'équipe : state_clear(mode="team", session_id)
7. Rapportez un résumé structuré à l'utilisateur

Si Autopilot est actif

Autopilot gère son propre nettoyage primaire en premier : les workflows nommés suppriment en plus uniquement leur état de mise en vigueur ralplan imbriqué appartenant à la session avant le ralph lié et le nettoyage ultraqa retiré.

1. Lisez l'état autopilot via state_read(mode="autopilot", session_id) pour capturer l'exécution exacte en cours, y compris workflowRunId lorsqu'il est présent.
2. Mettez en pause cette exécution exacte avec la mutation étroite state_write(mode="autopilot", session_id, active=false, state={workflowRunId: "<id d'exécution exact>"}). Ne rejouez pas ni ne copiez la relecture de l'état. Sur Linux avec flock, l'outil revalide l'exécution détenue et l'intégrité du workflow sous son verrou de mutation avant de modifier uniquement active en false ; il préserve le workflow, le suivi du pipeline et l'identité de la tâche. target_state_sha256 peut être inclus uniquement s'il s'agit du SHA-256 exact de l'état sérialisé actuel.
   • Si cette écriture échoue, arrêtez immédiatement. N'effacez pas le ralplan imbriqué, l'état lié, les signaux d'annulation ou les artefacts d'exécution.
3. Pour un workflow nommé, effacez uniquement l'état ralplan appartenant au même session_id ; n'effacez jamais l'état ralplan autonome d'une autre session. Enregistrez un échec mais gardez le primaire en pause récupérable.
4. Seulement après que la pause primaire soit validée, vérifiez le ralph lié via `state_read(mode="ra