cancelar

Habilidad Cancelar

Cancelación inteligente que detecta y cancela el modo OMC activo.

La habilidad cancelar es la forma estándar de completar y salir de cualquier modo OMC. Cuando el 'stop hook' detecta que el trabajo está completo, indica al LLM que invoque esta habilidad para una limpieza de estado adecuada. Si cancelar falla o es interrumpido, reintente con la bandera --force, o espere el tiempo de espera de 2 horas como último recurso.

Qué Hace

Detecta automáticamente qué modo está activo y lo cancela:

• Autopilot: Detiene el flujo de trabajo, preserva el progreso para reanudar
• Ralph: Detiene el bucle de persistencia
• Estado Ultrawork heredado: Eliminación solo de limpieza para instalaciones actualizadas; no es un flujo de trabajo activo
• UltraQA (retirado): No queda flujo de trabajo activo; limpia el obsoleto ultraqa-state.json anterior a la v5.0.0 si está presente
• Ultragoal: Limpia la guarda de ejecución de ultragoal con ámbito de sesión (.omc/state/.../ultragoal-state.json) para que la aplicación de reglas /goal de PreToolUse y la consolidación de Stop se liberen. Los artefactos duraderos de plan/registro .omc/ultragoal/ se conservan.
• Swarm: Detiene el enjambre de agentes coordinados, libera las tareas reclamadas
• Ultrapilot: Detiene los trabajadores paralelos de autopilot
• Pipeline: Detiene la tubería secuencial de agentes
• Team: Solicita el apagado de todos los compañeros de equipo a través de la superficie de conversación/equipo activa, espera respuestas/tiempos de espera, limpia el estado del equipo OMC, limpia el ralph vinculado si está presente. Claude Code 2.1.178+ no tiene TeamDelete.
• Team+Ralph (vinculado): Cancela el equipo primero (apagado ordenado), luego limpia el estado de ralph. Cancelar ralph cuando está vinculado también cancela el equipo primero.

Uso

/oh-my-claudecode:cancel

O diga: "cancelomc", "stopomc"

Crítico: Manejo de Herramientas Diferidas

Las herramientas de gestión de estado (state_clear, state_read, state_write, state_list_active, state_get_status) pueden estar registradas como herramientas diferidas por Claude Code. Antes de llamar a cualquier herramienta de estado, DEBE cargarlas todas primero mediante 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 no está disponible o falla, use este respaldo de bash como una escapatoria de emergencia del bucle de stop hook. Esto NO es un reemplazo completo del flujo de cancelación: solo elimina archivos de estado para desbloquear la sesión. Los modos activos vinculados (por ejemplo, autopilot→ralph) deben limpiarse por separado ejecutando el respaldo una vez por modo.

Reemplace MODE con el modo específico (por ejemplo, ralplan, ralph, ultrawork, ultragoal).

ADVERTENCIA: NO use este respaldo para autopilot o omc-teams. Autopilot requiere state_write(active=false) para preservar los datos de reanudación. omc-teams requiere una limpieza de la sesión de tmux que no se puede realizar solo con la eliminación de archivos.

# Respaldo: eliminación directa de archivos cuando la herramienta MCP state_clear no está disponible
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 multiplataforma (macOS: shasum, Linux: sha256sum)
sha256portable() { printf '%s' "$1" | (sha256sum 2>/dev/null || shasum -a 256) | cut -c1-16; }

# Resolver el directorio de estado (soporta almacenamiento centralizado OMC_STATE_DIR)
if [ -n "${OMC_STATE_DIR:-}" ]; then
  # Reflejar getProjectIdentifier() de 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 "ERROR: Directorio de estado no encontrado en $OMC_STATE" >&2; exit 1; }
elif [ "$REPO_ROOT" != "/" ] && [ -d "$REPO_ROOT/.omc" ]; then
  OMC_STATE="$REPO_ROOT/.omc/state"
else
  echo "ERROR: No se pudo localizar el directorio de estado .omc" >&2
  exit 1
fi
MODE="ralplan"  # <-- reemplace con el modo objetivo

# Limpiar el estado con ámbito de sesión para el modo específico
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"
  # Escribir señal de cancelación para que el stop hook detecte la cancelación en curso
  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
)"
  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

# Limpiar estado heredado solo si no hay ID de sesión (evitar limpiar el estado de otra sesión)
if [ -z "$SESSION_ID" ]; then
  rm -f "$OMC_STATE/${MODE}-state.json"
fi

Detección Automática

/oh-my-claudecode:cancel sigue el contrato de estado por sesión:

• Por defecto, el comando inspecciona la sesión actual mediante state_list_active y state_get_status, navegando .omc/state/sessions/{sessionId}/… para descubrir qué modo está activo.
• Cuando se proporciona o ya se conoce un id de sesión, esa ruta con ámbito de sesión es autoritativa. Los archivos heredados en .omc/state/*.json se consultan solo como respaldo de compatibilidad si el id de sesión falta o está vacío.
• Swarm es un modo compartido SQLite/marcador (.omc/state/swarm.db / .omc/state/swarm-active.marker) y no tiene ámbito de sesión.
• El flujo de limpieza predeterminado llama a state_clear con el id de sesión para eliminar solo los archivos de sesión coincidentes; los modos permanecen vinculados a su sesión de origen.

Los modos activos aún se cancelan en orden de dependencia:

1. Autopilot (incluye ralph vinculado y limpieza de estado retirado)
2. Ralph
3. Limpieza de estado Ultrawork/UltraQA heredado
4. Ultragoal (guarda de ejecución independiente — state_clear(mode="ultragoal"); preserva artefactos duraderos .omc/ultragoal/)
5. Swarm (independiente)
6. Ultrapilot (independiente)
7. Pipeline (independiente)
8. Team (Claude Code nativo)
9. OMC Teams (trabajadores CLI de tmux)
10. Plan Consensus (independiente)
11. Self-Improve (independiente — limpia estado, limpia worktrees huérfanos, preserva iteration_state para reanudar, establece estado: "user_stopped" en el <self-improve-root>/state/agent-settings.json resuelto; las nuevas ejecuciones usan .omc/self-improve/topics/<topic-slug>/, con .omc/self-improve/ plano conservado solo para reanudaciones heredadas de una sola pista)

Forzar Limpieza Total

Use --force o --all cuando necesite borrar cada sesión más los artefactos heredados, por ejemplo, para restablecer el espacio de trabajo por completo.

/oh-my-claudecode:cancel --force

/oh-my-claudecode:cancel --all

Pasos internos:

1. state_list_active enumera .omc/state/sessions/{sessionId}/… para encontrar cada sesión conocida.
2. state_clear se ejecuta una vez por sesión para eliminar los archivos de esa sesión.
3. Un state_clear global sin session_id elimina los archivos heredados en .omc/state/*.json, .omc/state/swarm*.db y artefactos de compatibilidad (ver lista).
4. Los artefactos de equipo (~/.claude/teams/*/, ~/.claude/tasks/*/, .omc/state/team-state.json) se limpian en el mejor esfuerzo como parte del respaldo heredado.
   • La cancelación para equipo nativo NO afecta el estado de omc-teams, y viceversa.

Cada comando state_clear respeta el argumento session_id, por lo que incluso el modo forzado usa primero las rutas por sesión antes de eliminar archivos heredados.

Lista de compatibilidad heredada (eliminada solo bajo --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/ (directorio)
• .omc/state/sessions/ (limpieza de directorio vacío después de borrar sesiones)

Pasos de Implementación

Cuando invoque esta habilidad:

1. Analizar Argumentos

# Verificar las banderas --force o --all
FORCE_MODE=false
if [[ "$*" == *"--force"* ]] || [[ "$*" == *"--all"* ]]; then
  FORCE_MODE=true
fi

2. Detectar Modos Activos

La habilidad ahora se basa en el contrato de estado por sesión en lugar de rutas de archivo fijas:

1. Llame a state_list_active para enumerar .omc/state/sessions/{sessionId}/… y descubrir cada sesión activa.
2. Para cada id de sesión, llame a state_get_status para saber qué modo activo se está ejecutando y si existen modos dependientes; trate cualquier registro de Ultrawork solo como entrada de limpieza retirada.
3. Si se proporcionó un session_id a /oh-my-claudecode:cancel, omita el respaldo heredado por completo y opere únicamente dentro de esa ruta de sesión; de lo contrario, consulte los archivos heredados en .omc/state/*.json solo si las herramientas de estado informan que no hay sesión activa. Swarm sigue siendo un modo SQLite/marcador compartido fuera del ámbito de la sesión.
4. Cualquier lógica de cancelación en este documento refleja el orden de dependencia descubierto a través de las herramientas de estado (autopilot → ralph → …).

3A. Modo Forzado (si --force o --all)

Use el modo forzado para limpiar cada sesión más los artefactos heredados mediante state_clear. La eliminación directa de archivos se reserva para la limpieza heredada cuando las herramientas de estado informan que no hay sesiones activas.

3B. Cancelación Inteligente (predeterminado)

Si Team Activo (equipo implícito de Claude Code)

Los equipos se detectan a través del estado del equipo OMC, no de los directorios de configuración ~/.claude/teams eliminados de Claude Code:

# Verificar el estado activo del equipo OMC
state_read(mode="team")

Protocolo de cancelación en dos pasos:

Paso 1: Apagado Ordenado

Para el estado activo del equipo OMC:
  1. Leer team_name y etiquetas de trabajador desde el estado OMC/traspasos/contabilidad de tareas
  2. Para cada compañero de equipo activo:
     a. Preguntar o notificar al compañero de equipo nombrado a través de la superficie de mensajería/conversación de equipo activa
     b. Esperar hasta 15 segundos por shutdown_response
     c. Si se recibe respuesta: marcar miembro como reconocido
     d. Si se agota el tiempo: marcar miembro como no receptivo, continuar con el siguiente
  3. Registrar: "Paso ordenado: X/Y miembros respondieron"

Paso 2: Reconciliación

Después del paso ordenado:
  1. Esperar 5 segundos más para compañeros de equipo no receptivos que aún puedan estar procesando
  2. Registrar cualquier compañero de equipo no receptivo restante en el informe de cancelación
  3. No llamar a TeamDelete; Claude Code 2.1.178+ eliminó la limpieza nativa por equipo

Limpieza de Estado OMC:

  1. Limpiar estado del equipo: state_clear(mode="team")
  2. Verificar ralph vinculado: state_read(mode="ralph") — si linked_team es verdadero:
     a. Limpiar estado de ralph: state_clear(mode="ralph")
  3. Ejecutar escaneo de huérfanos OMC tmux/CLI solo para trabajadores `omc team` / `/omc-teams` heredados (ver abajo)
  4. Emitir informe de cancelación estructurado

Detección de Huérfanos (Post-Limpieza):

Para ejecuciones de trabajadores OMC tmux/CLI heredados, verificar que no queden procesos de trabajador:

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

El escáner de huérfanos:

1. Verifica ps aux (Unix) o tasklist (Windows) en busca de procesos de trabajador OMC con --team-name que coincida con el equipo limpiado
2. Envía SIGTERM, espera 5s, envía SIGKILL si aún está vivo
3. Informa los resultados de la limpieza como JSON

Use --dry-run para inspeccionar sin matar. El escáner es seguro de ejecutar múltiples veces.

Informe de Cancelación Estructurado:

Equipo "{team_name}" cancelado:
  - Miembros señalados: N
  - Respuestas recibidas: M
  - No receptivos: K (listar nombres si los hay)
  - Estado OMC limpiado: sí/no
  - Limpieza manual necesaria: sí/no
    Ruta: estado del equipo OMC / procesos de trabajador tmux, si los hay

Nota de implementación: La habilidad cancelar es ejecutada por el LLM, no como un script bash. Cuando detecte un equipo activo:

1. Leer state_read(mode="team") para encontrar el equipo OMC activo
2. Identificar compañeros de equipo activos nombrados desde el estado, traspasos o contabilidad de tareas
3. Para cada compañero de equipo, preguntar o notificar al compañero nombrado a través de la superficie de mensajería/conversación de equipo activa
4. Esperar brevemente las respuestas de apagado (tiempo de espera de 15s por miembro)
5. Registrar compañeros de equipo no receptivos después de una espera de reconciliación
6. Limpiar el estado del equipo: state_clear(mode="team", session_id)
7. Informar resumen estructurado al usuario

Si Autopilot Activo

Autopilot maneja su propia limpieza primaria primero: los flujos de trabajo nombrados eliminan adicionalmente solo su estado de aplicación ralplan anidado propiedad de la sesión antes del ralph vinculado y la limpieza ultraqa retirada.

1. Leer el estado de autopilot mediante state_read(mode="autopilot", session_id) para capturar la ejecución actual exacta, incluyendo workflowRunId cuando esté presente.
2. Pausar esa ejecución exacta con la mutación estrecha state_write(mode="autopilot", session_id, active=false, state={workflowRunId: "<id de ejecución exacto>"}). No reproduzca ni copie la lectura de estado. En Linux con flock, la herramienta revalida la ejecución retenida y la integridad del flujo de trabajo bajo su bloqueo de mutación antes de cambiar solo active a false; preserva flujo de trabajo, seguimiento de tubería e identidad de tarea. target_state_sha256 puede incluirse solo cuando es el SHA-256 exacto del estado serializado actual.
   • Si esta escritura falla, deténgase inmediatamente. No limpie ralplan anidado, estado vinculado, señales de cancelación o artefactos de ejecución.
3. Para un flujo de trabajo nombrado, limpiar solo el estado ralplan propiedad del mismo session_id; nunca limpiar el estado ralplan independiente de otra sesión. Registrar un fallo pero mantener la primaria pausada reanudable.
4. Solo después de que la pausa primaria se confirme, verificar ralph vinculado mediante state_read(mode="ralph", session_id); si linked_to_autopilot es verdadero, llamar a state_clear(mode="ralph", session_id).
5. Solo entonces limpiar artefactos ultraqa retirados (pre-5.0.0) en .omc/state/sessions/{sessionId}/ultraqa-state.json y .omc/state/ultraqa-state.json a través de la herramienta.
6. No establecer señal de cancelación; el stop hook la escribe. Registrar un objeto de resultado que contenga cada paso con su estado (éxito/fallo).

Resumen: La cancelación de autopilot garantiza que una ejecución pausada pueda reanudarse más tarde llamando a /oh-my-claudecode:autopilot con el workflowRunId idéntico. No se pierde ningún progreso.

Si Ralph Activo

state_read(mode="ralph")
state_clear(mode="ralph")

Si Swarm Activo

state_read(mode="swarm")
state_clear(mode="swarm")

Si Ultrapilot Activo

state_read(mode="ultrapilot")
state_clear(mode="ultrapilot")

Si Pipeline Activo

state_read(mode="pipeline")
state_clear(mode="pipeline")

4. Informar Resultados

Después de la cancelación, devolver un bloque de código fenced con un objeto JSON estructurado que describa el resultado de la cancelación:

{
  "cancelled_modes": {
    "autopilot": "paused",
    "ralph": "cleared",
    "ultragoal": "cleared",
    "legacy_ultrawork": "not_found",
    "legacy_ultraqa": "not_found",
    "swarm": "cleared",
    "ultrapilot": "cleared",
    "pipeline": "cleared",
    "team": "cleared"
  },
  "session_id": "abc123",
  "legacy_cleanup": false,
  "force_mode": false,
  "manual_cleanup_required": []
}

Incluir:

• cancelled_modes: objeto que mapea cada modo a su estado de cancelación ("paused", "cleared", "not_found", "failed")
• session_id: el ID de sesión que se canceló, si corresponde
• legacy_cleanup: booleano, verdadero si se limpiaron archivos heredados
• force_mode: booleano, verdadero si se usó --force
• manual_cleanup_required: matriz de rutas/sugerencias para cualquier limpieza que no pudo realizarse automáticamente