cancelar

Skill Cancelar

Cancelamento inteligente que detecta e cancela o modo OMC ativo.

A skill cancelar é a forma padrão de concluir e sair de qualquer modo OMC. Quando o hook de parada detecta que o trabalho está completo, ele instrui o LLM a invocar esta skill para a limpeza adequada do estado. Se o cancelamento falhar ou for interrompido, tente novamente com a flag --force, ou aguarde o timeout de 2 horas de stale como último recurso.

O Que Ela Faz

Detecta automaticamente qual modo está ativo e o cancela:

• Autopilot: Interrompe o fluxo de trabalho, preserva o progresso para retomada
• Ralph: Interrompe o loop de persistência
• Estado Ultrawork legado: Remoção apenas de limpeza para instalações atualizadas; não é um fluxo de trabalho ativo
• UltraQA (aposentado): Nenhum fluxo de trabalho ativo permanece; limpa ultraqa-state.json pré-5.0.0 se presente
• Ultragoal: Limpa o guardião de runtime ultragoal com escopo de sessão (.omc/state/.../ultragoal-state.json) para que a aplicação /goal do PreToolUse e a reforçação de parada sejam liberadas. Artefatos duráveis .omc/ultragoal/ de plano/ledger são preservados.
• Swarm: Interrompe o enxame coordenado de agentes, libera tarefas reivindicadas
• Ultrapilot: Interrompe os workers paralelos do autopilot
• Pipeline: Interrompe o pipeline sequencial de agentes
• Team: Solicita desligamento de todos os colegas de equipe através da superfície ativa de equipe/conversação, aguarda respostas/timeouts, limpa o estado OMC da equipe, limpa o ralph vinculado se presente. Claude Code 2.1.178+ não tem TeamDelete.
• Team+Ralph (vinculado): Cancela a equipe primeiro (desligamento gracioso), depois limpa o estado do ralph. Cancelar ralph quando vinculado também cancela a equipe primeiro.

Uso

/oh-my-claudecode:cancel

Ou diga: "cancelomc", "stopomc"

Crítico: Manipulação de Ferramentas Adiadas

As ferramentas de gerenciamento de estado (state_clear, state_read, state_write, state_list_active, state_get_status) podem ser registradas como ferramentas adiadas pelo Claude Code. Antes de chamar qualquer ferramenta de estado, você DEVE primeiro carregar todas elas 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")

Se state_clear estiver indisponível ou falhar, use este fallback bash como uma saída de emergência do loop do hook de parada. Isto NÃO é uma substituição completa para o fluxo de cancelamento — ele apenas remove arquivos de estado para desbloquear a sessão. Modos ativos vinculados (por exemplo, autopilot→ralph) devem ser limpos separadamente executando o fallback uma vez por modo.

Substitua MODE pelo modo específico (ex.: ralplan, ralph, ultrawork, ultragoal).

AVISO: NÃO use este fallback para autopilot ou omc-teams. O Autopilot requer state_write(active=false) para preservar dados de retomada. O omc-teams requer limpeza de sessão tmux que não pode ser feita apenas com exclusão de arquivos.

# Fallback: remoção direta de arquivos quando a ferramenta MCP state_clear está indisponível
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; }

# Resolve o diretório de estado (suporta armazenamento centralizado OMC_STATE_DIR)
if [ -n "${OMC_STATE_DIR:-}" ]; then
  # Espelha 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: State dir not found at $OMC_STATE" >&2; exit 1; }
elif [ "$REPO_ROOT" != "/" ] && [ -d "$REPO_ROOT/.omc" ]; then
  OMC_STATE="$REPO_ROOT/.omc/state"
else
  echo "ERROR: Could not locate .omc state directory" >&2
  exit 1
fi
MODE="ralplan"  # <-- substitua pelo modo alvo

# Limpa o estado com escopo de sessão para o 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"
  # Escreve sinal de cancelamento para que o hook de parada detecte o cancelamento em andamento
  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

# Limpa estado legado apenas se não houver ID de sessão (evita limpar o estado de outra sessão)
if [ -z "$SESSION_ID" ]; then
  rm -f "$OMC_STATE/${MODE}-state.json"
fi

Detecção Automática

/oh-my-claudecode:cancel segue o contrato de estado com reconhecimento de sessão:

• Por padrão, o comando inspeciona a sessão atual via state_list_active e state_get_status, navegando por .omc/state/sessions/{sessionId}/… para descobrir qual modo está ativo.
• Quando um ID de sessão é fornecido ou já conhecido, esse caminho com escopo de sessão é autoritativo. Arquivos legados em .omc/state/*.json são consultados apenas como fallback de compatibilidade se o ID de sessão estiver ausente ou vazio.
• Swarm é um modo compartilhado SQLite/marcador (.omc/state/swarm.db / .omc/state/swarm-active.marker) e não tem escopo de sessão.
• O fluxo de limpeza padrão chama state_clear com o ID da sessão para remover apenas os arquivos correspondentes à sessão; os modos permanecem vinculados à sua sessão de origem.

Os modos ativos ainda são cancelados na ordem de dependência:

1. Autopilot (inclui ralph vinculado e limpeza de estado aposentado)
2. Ralph
3. Limpeza de estado legado Ultrawork/UltraQA
4. Ultragoal (guardião de runtime independente — state_clear(mode="ultragoal"); preserva artefatos duráveis .omc/ultragoal/)
5. Swarm (independente)
6. Ultrapilot (independente)
7. Pipeline (independente)
8. Team (nativo do Claude Code)
9. OMC Teams (workers CLI tmux)
10. Plan Consensus (independente)
11. Self-Improve (independente — limpar estado, limpar worktrees órfãos, preservar iteration_state para retomada, definir status: "user_stopped" no <self-improve-root>/state/agent-settings.json resolvido; novas execuções usam .omc/self-improve/topics/<topic-slug>/, com .omc/self-improve/ mantido apenas para retomadas legadas de trilha única)

Forçar Limpeza Total

Use --force ou --all quando precisar apagar todas as sessões e artefatos legados, por exemplo, para redefinir completamente o workspace.

/oh-my-claudecode:cancel --force

/oh-my-claudecode:cancel --all

Etapas internas:

1. state_list_active enumera .omc/state/sessions/{sessionId}/… para encontrar todas as sessões conhecidas.
2. state_clear é executado uma vez por sessão para remover os arquivos dessa sessão.
3. Um state_clear global sem session_id remove arquivos legados em .omc/state/*.json, .omc/state/swarm*.db e artefatos de compatibilidade (veja lista).
4. Artefatos de equipe (~/.claude/teams/*/, ~/.claude/tasks/*/, .omc/state/team-state.json) são limpos na melhor das hipóteses como parte do fallback legado.
   • O cancelamento da equipe nativa NÃO afeta o estado do omc-teams, e vice-versa.

Cada comando state_clear respeita o argumento session_id, portanto, mesmo o modo forçado ainda usa os caminhos com reconhecimento de sessão antes de excluir arquivos legados.

Lista de compatibilidade legada (removida apenas com --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/ (diretório)
• .omc/state/sessions/ (limpeza de diretório vazio após limpar as sessões)

Etapas de Implementação

Quando você invocar esta skill:

1. Analisar Argumentos

# Verificar as flags --force ou --all
FORCE_MODE=false
if [[ "$*" == *"--force"* ]] || [[ "$*" == *"--all"* ]]; then
  FORCE_MODE=true
fi

2. Detectar Modos Ativos

A skill agora depende do contrato de estado com reconhecimento de sessão, em vez de caminhos de arquivo codificados:

1. Chame state_list_active para enumerar .omc/state/sessions/{sessionId}/… e descobrir todas as sessões ativas.
2. Para cada ID de sessão, chame state_get_status para saber qual modo ativo está em execução e se existem modos dependentes; trate qualquer registro Ultrawork como entrada de limpeza apenas para itens aposentados.
3. Se um session_id foi fornecido para /oh-my-claudecode:cancel, ignore o fallback legado completamente e opere apenas dentro desse caminho de sessão; caso contrário, consulte arquivos legados em .omc/state/*.json apenas se as ferramentas de estado informarem que não há sessão ativa. Swarm permanece um modo compartilhado SQLite/marcador fora do escopo da sessão.
4. Qualquer lógica de cancelamento neste documento espelha a ordem de dependência descoberta através das ferramentas de estado (autopilot → ralph → …).

3A. Modo Forçado (se --force ou --all)

Use o modo forçado para limpar todas as sessões e artefatos legados via state_clear. A remoção direta de arquivos é reservada para limpeza legada quando as ferramentas de estado informarem que não há sessões ativas.

3B. Cancelamento Inteligente (padrão)

Se o Time Estiver Ativo (time implícito do Claude Code)

Os times são detectados através do estado OMC do time, não dos diretórios de configuração ~/.claude/teams removidos do Claude Code:

# Verificar estado OMC de time ativo
state_read(mode="team")

Protocolo de cancelamento em duas passagens:

Passagem 1: Desligamento Gracioso

Para o estado OMC de time ativo:
  1. Ler team_name e rótulos dos workers do estado/registro de tarefas OMC
  2. Para cada colega de equipe ativo:
     a. Perguntar ou notificar o colega nomeado através da superfície de mensagens da equipe/conversação ativa
     b. Aguardar até 15 segundos por shutdown_response
     c. Se resposta recebida: marcar membro como reconhecido
     d. Se timeout: marcar membro como sem resposta, continuar para o próximo
  3. Registrar: "Passagem graciosa: X/Y membros responderam"

Passagem 2: Reconciliação

Após a passagem graciosa:
  1. Aguardar mais 5 segundos para colegas sem resposta que ainda podem estar processando
  2. Registrar quaisquer colegas sem resposta restantes no relatório de cancelamento
  3. Não chamar TeamDelete; Claude Code 2.1.178+ removeu a limpeza nativa por time

Limpeza do Estado OMC:

  1. Limpar estado do time: state_clear(mode="team")
  2. Verificar ralph vinculado: state_read(mode="ralph") — se linked_team for true:
     a. Limpar estado do ralph: state_clear(mode="ralph")
  3. Executar varredura de órfãos OMC tmux/CLI apenas para workers legados `omc team` / `/omc-teams` (veja abaixo)
  4. Emitir relatório de cancelamento estruturado

Detecção de Órfãos (Pós-Limpeza):

Para execuções legadas de workers OMC tmux/CLI, verificar se nenhum processo worker permanece:

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

O scanner de órfãos:

1. Verifica ps aux (Unix) ou tasklist (Windows) por processos worker OMC com --team-name correspondente ao time limpo
2. Envia SIGTERM, aguarda 5s, envia SIGKILL se ainda estiver ativo
3. Relata resultados da limpeza como JSON

Use --dry-run para inspecionar sem matar. O scanner é seguro para executar várias vezes.

Relatório de Cancelamento Estruturado:

Time "{team_name}" cancelado:
  - Membros sinalizados: N
  - Respostas recebidas: M
  - Sem resposta: K (listar nomes se houver)
  - Estado OMC limpo: sim/não
  - Limpeza manual necessária: sim/não
    Caminho: estado OMC do time / processos worker tmux, se houver

Nota de implementação: A skill cancelar é executada pelo LLM, não como um script bash. Quando você detectar um time ativo:

1. Leia state_read(mode="team") para encontrar o time OMC ativo
2. Identifique colegas de equipe ativos nomeados a partir do estado, handoffs ou registro de tarefas
3. Para cada colega, pergunte ou notifique o colega nomeado através da superfície de mensagens da equipe/conversação ativa
4. Aguarde brevemente por respostas de desligamento (timeout de 15s por membro)
5. Registre colegas sem resposta após uma espera de reconciliação
6. Limpe o estado do time: state_clear(mode="team", session_id)
7. Relate um resumo estruturado ao usuário

Se o Autopilot Estiver Ativo

O Autopilot lida com sua própria limpeza primária primeiro: fluxos de trabalho nomeados adicionalmente removem apenas o estado de aplicação ralplan aninhado de sua própria sessão antes do ralph vinculado e da limpeza do ultraqa aposentado.

1. Leia o estado do autopilot via state_read(mode="autopilot", session_id) para capturar a execução atual exata, incluindo workflowRunId quando presente.
2. Pause essa execução exata com a mutação restrita state_write(mode="autopilot", session_id, active=false, state={workflowRunId: "<id da execução exata>"}). Não **reproduza ou copie a leitura de estado de volta. No Linux com flock, a ferramenta revalida a execução mantida e a integridade do fluxo de trabalho sob seu bloqueio de mutação antes de alterar apenas active para false; ela preserva o fluxo de trabalho, o rastreamento do pipeline e a identidade da tarefa. target_state_sha256 pode ser incluído apenas quando for o SHA-256 exato do estado serializado atual.
   • Se esta gravação falhar, pare imediatamente. Não limpe ralplan aninhado, estado vinculado, sinais de cancelamento ou artefatos de runtime.
3. Para um fluxo de trabalho nomeado, limpe apenas o estado ralplan de propriedade do mesmo session_id; nunca limpe o estado ralplan independente de outra sessão. Registre uma falha, mas mantenha o primário pausado retomável.
4. Somente após a pausa primária ser confirmada, verifique o ralph vinculado via state_read(mode="ralph", session_id) — se linked_autopilot for true, limpe o estado do ralph com state_clear(mode="ralph", session_id). Se a limpeza do ralph falhar, registre um aviso, mas não reverta a pausa do autopilot.
5. Como etapa de compatibilidade final, limpe quaisquer arquivos de estado legados do ultraqa que estejam no escopo da sessão (.omc/state/sessions/{sessionId}/ultraqa-state.json). Isto é apenas uma limpeza; não há modo ativo para cancelar.
6. Emita um relatório de status para o usuário confirmando que o autopilot foi pausado e quais limpezas dependentes ocorreram.

Se o Ralph Estiver Ativo (sem vínculo com autopilot ou time)

1. Leia o estado do ralph via state_read(mode="ralph", session_id) para capturar o estado atual da execução.
2. Interrompa o loop de persistência definindo active=false: state_write(mode="ralph", session_id, active=false).
   • Se a gravação falhar, pare e informe o usuário.
3. Se o ralph estava conduzindo uma iteração de autopilot (detectado por linked_autopilot=true a partir da leitura do estado do ralph), cancele o autopilot primeiro usando a lógica da seção autopilot.
4. Se estiver vinculado a um time: cancele o time primeiro (protocolo de duas passagens acima) e depois limpe o estado do ralph.
5. Após a interrupção bem-sucedida, limpe o estado do ralph via state_clear(mode="ralph", session_id) para remover quaisquer marcadores de sessão restantes.

Se o Time OMC Estiver Ativo (workers tmux)

A detecção de times OMC usa a presença de marcadores de time independentes.

# Verificar marcadores de time OMC legados
ls .omc/state/omc-teams-*.json 2>/dev/null && echo "Legacy OMC team state found"

Protocolo de desligamento:

1. Para cada marcador de time OMC encontrado:
   a. Ler seu team_name e worker_labels
   b. Tentar sinalizar graciosamente cada worker tmux via tmux send-keys (para workers que
      suportam shutdown_request)
   c. Para workers que não respondem após 10s, enviar SIGTERM para o processo tmux associado
   d. Aguardar 5s para desligamento
   e. Para workers persistentes, enviar SIGKILL
2. Remover todos os arquivos de estado omc-teves:
   rm -f .omc/state/omc-teams-*.json
   rm -f .omc/state/omc-teams-state.json

Nota: As janelas tmux em si podem persistir. O usuário pode precisar fechá-las manualmente com tmux kill-session -t <session_name>.

Se Outro Modo Estiver Ativo (ultragoal, ultrapilot, swarm, pipeline, etc.)

A chave é que a skill agora usa state_read(mode="<mode>", session_id) para cada modo potencial que poderia estar ativo, em vez de verificar caminhos de arquivo fixos.

1. Chame state_read(mode="ultragoal", session_id) para ler o guardião de runtime ultragoal associado a esta sessão.
2. Chame state_read(mode="ultrapilot", session_id) / state_read(mode="swarm") (sem session_id para swarm) / state_read(mode="pipeline", session_id).
3. Para cada modo que retornar um estado ativo, chame state_clear(mode="<mode>", session_id).

Ultragoal: Limpa o estado do guardião de runtime: state_clear(mode="ultragoal", session_id). Artefatos duráveis .omc/ultragoal/ são preservados.

Swarm: Use a ferramenta de estado sem session_id porque swarm é um modo compartilhado: state_clear(mode="swarm"). Isto remove .omc/state/swarm.db, .omc/state/swarm-active.marker e artefatos associados.

Ultrapilot: state_clear(mode="ultrapilot", session_id). Paralisa todos os workers paralelos registrados.

Pipeline: state_clear(mode="pipeline", session_id). Interrompe a execução do pipeline.

Self-Improve: Leia state_read(mode="self-improve", session_id) para capturar o estado atual da iteração. Chame state_clear(mode="self-improve", session_id) e defina user_stopped no arquivo agent-settings.json do workspace: state_write(mode="self-improve", session_id, state={"status":"user_stopped"}). Worktrees órfãos são limpos por state_clear. O diretório .omc/self-improve é preservado.

4A. Cancelamento de Último Recurso (Ferramentas de Estado Indisponíveis)

Se as ferramentas de estado MCP não estiverem disponíveis (por exemplo, após falha do ToolSearch), use o script de fallback bash fornecido acima. Este fallback é apenas para situações de emergência onde o LLM não pode usar as ferramentas MCP.

4B. Relatório de Status

Após o cancelamento, relate um resumo ao usuário:

Cancelamento concluído:
  - Sessão: <session_id>
  - Modo autopilot: pausado / não estava ativo / falha
  - Modo ralph: limpo / não estava ativo / falha
  - Modo ultragoal: limpo / não estava ativo / falha
  - Modo swarm: limpo / não estava ativo / falha
  - Modo ultragoal: limpo / não estava ativo / falha
  - Modo ultrapilot: limpo / não estava ativo / falha
  - Modo pipeline: limpo / não estava ativo / falha
  - Modo time: limpo / não estava ativo / falha

Comportamento de Fallback de Último Recurso

Se esta skill falhar em cancelar o modo ativo (talvez devido a ferramentas MCP indisponíveis), o Claude Code tentará novamente a skill cancel — não há necessidade de invocar um fallback separado.

Se mesmo a nova tentativa falhar, notifique o usuário e recomende esperar pelo timeout de 2 horas de stale, que irá liberar o hook de parada.

Histórico de Compatibilidade

• pré-v2.0.0: Usava exclusão direta de arquivos para todos os modos; sem reconhecimento de sessão.
• v2.0.0+ (atual): Usa ferramentas de estado state_read/state_write/state_clear com contrato baseado em sessão.
• Claude Code >= 2.1.178: Ferramentas de estado registradas como ferramentas adiadas; precisa de ToolSearch antes do uso.