Cancel Skill

Intelligent cancellation that detects and cancels the active OMC mode.

The cancel skill is the standard way to complete and exit any OMC mode. When the stop hook detects work is complete, it instructs the LLM to invoke this skill for proper state cleanup. If cancel fails or is interrupted, retry with

--force

flag, or wait for the 2-hour staleness timeout as a last resort.

What It Does

Automatically detects which mode is active and cancels it:

Autopilot: Stops workflow, preserves progress for resume
Ralph: Stops persistence loop, clears linked ultrawork if applicable
Ultrawork: Stops parallel execution (standalone or linked)
Ecomode: Stops token-efficient parallel execution (standalone or linked to ralph)
UltraQA: Stops QA cycling workflow
Swarm: Stops coordinated agent swarm, releases claimed tasks
Ultrapilot: Stops parallel autopilot workers
Pipeline: Stops sequential agent pipeline
Team: Sends shutdown_request to all teammates, waits for responses, calls TeamDelete, clears linked ralph if present
Team+Ralph (linked): Cancels team first (graceful shutdown), then clears ralph state. Cancelling ralph when linked also cancels team first.

Usage

/oh-my-claudecode:cancel

Or say: "cancelomc", "stopomc"

Auto-Detection

/oh-my-claudecode:cancel

follows the session-aware state contract:

By default the command inspects the current session via
```
state_list_active
```
and
```
state_get_status
```
, navigating
```
.omc/state/sessions/{sessionId}/…
```
to discover which mode is active.
When a session id is provided or already known, that session-scoped path is authoritative. Legacy files in
```
.omc/state/*.json
```
are consulted only as a compatibility fallback if the session id is missing or empty.
Swarm is a shared SQLite/marker mode (
```
.omc/state/swarm.db
```
/
```
.omc/state/swarm-active.marker
```
) and is not session-scoped.
The default cleanup flow calls
```
state_clear
```
with the session id to remove only the matching session files; modes stay bound to their originating session.

Active modes are still cancelled in dependency order:

Autopilot (includes linked ralph/ultraqa/ecomode cleanup)
Ralph (cleans its linked ultrawork or ecomode)
Ultrawork (standalone)
Ecomode (standalone)
UltraQA (standalone)
Swarm (standalone)
Ultrapilot (standalone)
Pipeline (standalone)
Team (Claude Code native)
Plan Consensus (standalone)

Force Clear All

Use

--force

--all

when you need to erase every session plus legacy artifacts, e.g., to reset the workspace entirely.

/oh-my-claudecode:cancel --force

/oh-my-claudecode:cancel --all

Steps under the hood:

state_list_active

enumerates

.omc/state/sessions/{sessionId}/…

to find every known session.

```
state_clear
```
runs once per session to drop that session’s files.
A global
```
state_clear
```
without
```
session_id
```
removes legacy files under
```
.omc/state/*.json
```
,
```
.omc/state/swarm*.db
```
, and compatibility artifacts (see list).
Team artifacts (
```
~/.claude/teams/*/
```
,
```
~/.claude/tasks/*/
```
,
```
.omc/state/team-state.json
```
) are best-effort cleared as part of the legacy fallback.

Every

state_clear

command honors the

session_id

argument, so even force mode still uses the session-aware paths first before deleting legacy files.

Legacy compatibility list (removed only under

--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/ecomode-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/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/
```
(directory)
```
.omc/state/sessions/
```
(empty directory cleanup after clearing sessions)

Implementation Steps

When you invoke this skill:

1. Parse Arguments

bash

# Check for --force or --all flags
FORCE_MODE=false
if [[ "$*" == *"--force"* ]] || [[ "$*" == *"--all"* ]]; then
  FORCE_MODE=true
fi

2. Detect Active Modes

The skill now relies on the session-aware state contract rather than hard-coded file paths:

Call

state_list_active

to enumerate

.omc/state/sessions/{sessionId}/…

and discover every active session.

For each session id, call
```
state_get_status
```
to learn which mode is running (
```
autopilot
```
,
```
ralph
```
,
```
ultrawork
```
, etc.) and whether dependent modes exist.
If a
```
session_id
```
was supplied to
```
/oh-my-claudecode:cancel
```
, skip legacy fallback entirely and operate solely within that session path; otherwise, consult legacy files in
```
.omc/state/*.json
```
only if the state tools report no active session. Swarm remains a shared SQLite/marker mode outside session scoping.
Any cancellation logic in this doc mirrors the dependency order discovered via state tools (autopilot → ralph → …).

3A. Force Mode (if --force or --all)

Use force mode to clear every session plus legacy artifacts via

state_clear

. Direct file removal is reserved for legacy cleanup when the state tools report no active sessions.

3B. Smart Cancellation (default)

If Team Active (Claude Code native)

Teams are detected by checking for config files in

~/.claude/teams/

bash

# Check for active teams
TEAM_CONFIGS=$(find ~/.claude/teams -name config.json -maxdepth 2 2>/dev/null)

Two-pass cancellation protocol:

Pass 1: Graceful Shutdown

For each team found in ~/.claude/teams/:
  1. Read config.json to get team_name and members list
  2. For each non-lead member:
     a. Send shutdown_request via SendMessage
     b. Wait up to 15 seconds for shutdown_response
     c. If response received: member terminates and is auto-removed
     d. If timeout: mark member as unresponsive, continue to next
  3. Log: "Graceful pass: X/Y members responded"

Pass 2: Reconciliation

After graceful pass:
  1. Re-read config.json to check remaining members
  2. If only lead remains (or config is empty): proceed to TeamDelete
  3. If unresponsive members remain:
     a. Wait 5 more seconds (they may still be processing)
     b. Re-read config.json again
     c. If still stuck: attempt TeamDelete anyway
     d. If TeamDelete fails: report manual cleanup path

TeamDelete + Cleanup:

  1. Call TeamDelete() — removes ~/.claude/teams/{name}/ and ~/.claude/tasks/{name}/
  2. Clear team state: state_clear(mode="team")
  3. Check for linked ralph: state_read(mode="ralph") — if linked_team is true:
     a. Clear ralph state: state_clear(mode="ralph")
     b. Clear linked ultrawork if present: state_clear(mode="ultrawork")
  4. Emit structured cancel report

Structured Cancel Report:

Team "{team_name}" cancelled:
  - Members signaled: N
  - Responses received: M
  - Unresponsive: K (list names if any)
  - TeamDelete: success/failed
  - Manual cleanup needed: yes/no
    Path: ~/.claude/teams/{name}/ and ~/.claude/tasks/{name}/

Implementation note: The cancel skill is executed by the LLM, not as a bash script. When you detect an active team:

Read
```
~/.claude/teams/*/config.json
```
to find active teams
If multiple teams exist, cancel oldest first (by
```
createdAt
```
)

For each non-lead member, call

SendMessage(type: "shutdown_request", recipient: member-name, content: "Cancelling")

Wait briefly for shutdown responses (15s per member timeout)
Re-read config.json to check for remaining members (reconciliation pass)
Call
```
TeamDelete()
```
to clean up
Remove any local state:
```
rm -f .omc/state/team-state.json
```
Report structured summary to user

If Autopilot Active

Call

cancelAutopilot()

from

src/hooks/autopilot/cancel.ts:27-78

bash

# Autopilot handles its own cleanup + ralph + ultraqa
# Just mark autopilot as inactive (preserves state for resume)
if [[ -f .omc/state/autopilot-state.json ]]; then
  # Clean up ralph if active
  if [[ -f .omc/state/ralph-state.json ]]; then
    RALPH_STATE=$(cat .omc/state/ralph-state.json)
    LINKED_UW=$(echo "$RALPH_STATE" | jq -r '.linked_ultrawork // false')

    # Clean linked ultrawork first
    if [[ "$LINKED_UW" == "true" ]] && [[ -f .omc/state/ultrawork-state.json ]]; then
      rm -f .omc/state/ultrawork-state.json
      echo "Cleaned up: ultrawork (linked to ralph)"
    fi

    # Clean ralph
    rm -f .omc/state/ralph-state.json
    rm -f .omc/state/ralph-verification.json
    echo "Cleaned up: ralph"
  fi

  # Clean up ultraqa if active
  if [[ -f .omc/state/ultraqa-state.json ]]; then
    rm -f .omc/state/ultraqa-state.json
    echo "Cleaned up: ultraqa"
  fi

  # Mark autopilot inactive but preserve state
  CURRENT_STATE=$(cat .omc/state/autopilot-state.json)
  CURRENT_PHASE=$(echo "$CURRENT_STATE" | jq -r '.phase // "unknown"')
  echo "$CURRENT_STATE" | jq '.active = false' > .omc/state/autopilot-state.json

  echo "Autopilot cancelled at phase: $CURRENT_PHASE. Progress preserved for resume."
  echo "Run /oh-my-claudecode:autopilot to resume."
fi

If Ralph Active (but not Autopilot)

Call

clearRalphState()

clearLinkedUltraworkState()

from

src/hooks/ralph-loop/index.ts:147-182

bash

if [[ -f .omc/state/ralph-state.json ]]; then
  # Check if ultrawork is linked
  RALPH_STATE=$(cat .omc/state/ralph-state.json)
  LINKED_UW=$(echo "$RALPH_STATE" | jq -r '.linked_ultrawork // false')

  # Clean linked ultrawork first
  if [[ "$LINKED_UW" == "true" ]] && [[ -f .omc/state/ultrawork-state.json ]]; then
    UW_STATE=$(cat .omc/state/ultrawork-state.json)
    UW_LINKED=$(echo "$UW_STATE" | jq -r '.linked_to_ralph // false')

    # Only clear if it was linked to ralph
    if [[ "$UW_LINKED" == "true" ]]; then
      rm -f .omc/state/ultrawork-state.json
      echo "Cleaned up: ultrawork (linked to ralph)"
    fi
  fi

  # Clean ralph state
  rm -f .omc/state/ralph-state.json
  rm -f .omc/state/ralph-plan-state.json
  rm -f .omc/state/ralph-verification.json

  echo "Ralph cancelled. Persistent mode deactivated."
fi

If Ultrawork Active (standalone, not linked)

Call

deactivateUltrawork()

from

src/hooks/ultrawork/index.ts:150-173

bash

if [[ -f .omc/state/ultrawork-state.json ]]; then
  # Check if linked to ralph
  UW_STATE=$(cat .omc/state/ultrawork-state.json)
  LINKED=$(echo "$UW_STATE" | jq -r '.linked_to_ralph // false')

  if [[ "$LINKED" == "true" ]]; then
    echo "Ultrawork is linked to Ralph. Use /oh-my-claudecode:cancel to cancel both."
    exit 1
  fi

  # Remove local state
  rm -f .omc/state/ultrawork-state.json

  echo "Ultrawork cancelled. Parallel execution mode deactivated."
fi

If UltraQA Active (standalone)

Call

clearUltraQAState()

from

src/hooks/ultraqa/index.ts:107-120

bash

if [[ -f .omc/state/ultraqa-state.json ]]; then
  rm -f .omc/state/ultraqa-state.json
  echo "UltraQA cancelled. QA cycling workflow stopped."
fi

No Active Modes

bash

echo "No active OMC modes detected."
echo ""
echo "Checked for:"
echo "  - Autopilot (.omc/state/autopilot-state.json)"
echo "  - Ralph (.omc/state/ralph-state.json)"
echo "  - Ultrawork (.omc/state/ultrawork-state.json)"
echo "  - UltraQA (.omc/state/ultraqa-state.json)"
echo ""
echo "Use --force to clear all state files anyway."

Implementation Notes

The cancel skill runs as follows:

Parse the
```
--force
```
/
```
--all
```
flags, tracking whether cleanup should span every session or stay scoped to the current session id.
Use
```
state_list_active
```
to enumerate known session ids and
```
state_get_status
```
to learn the active mode (
```
autopilot
```
,
```
ralph
```
,
```
ultrawork
```
, etc.) for each session.
When operating in default mode, call
```
state_clear
```
with that session_id to remove only the session’s files, then run mode-specific cleanup (autopilot → ralph → …) based on the state tool signals.
In force mode, iterate every active session, call
```
state_clear
```
per session, then run a global
```
state_clear
```
without
```
session_id
```
to drop legacy files (
```
.omc/state/*.json
```
, compatibility artifacts) and report success. Swarm remains a shared SQLite/marker mode outside session scoping.
Team artifacts (
```
~/.claude/teams/*/
```
,
```
~/.claude/tasks/*/
```
,
```
.omc/state/team-state.json
```
) remain best-effort cleanup items invoked during the legacy/global pass.

State tools always honor the

session_id

argument, so even force mode still clears the session-scoped paths before deleting compatibility-only legacy state.

Mode-specific subsections below describe what extra cleanup each handler performs after the state-wide operations finish.

Messages Reference

Mode	Success Message
Autopilot	"Autopilot cancelled at phase: {phase}. Progress preserved for resume."
Ralph	"Ralph cancelled. Persistent mode deactivated."
Ultrawork	"Ultrawork cancelled. Parallel execution mode deactivated."
Ecomode	"Ecomode cancelled. Token-efficient execution mode deactivated."
UltraQA	"UltraQA cancelled. QA cycling workflow stopped."
Swarm	"Swarm cancelled. Coordinated agents stopped."
Ultrapilot	"Ultrapilot cancelled. Parallel autopilot workers stopped."
Pipeline	"Pipeline cancelled. Sequential agent chain stopped."
Team	"Team cancelled. Teammates shut down and cleaned up."
Plan Consensus	"Plan Consensus cancelled. Planning session ended."
Force	"All OMC modes cleared. You are free to start fresh."
None	"No active OMC modes detected."

What Gets Preserved

Mode	State Preserved	Resume Command
Autopilot	Yes (phase, files, spec, plan, verdicts)	`/oh-my-claudecode:autopilot`
Ralph	No	N/A
Ultrawork	No	N/A
UltraQA	No	N/A
Swarm	No	N/A
Ultrapilot	No	N/A
Pipeline	No	N/A
Plan Consensus	Yes (plan file path preserved)	N/A

Notes

Dependency-aware: Autopilot cancellation cleans up Ralph and UltraQA
Link-aware: Ralph cancellation cleans up linked Ultrawork or Ecomode
Safe: Only clears linked Ultrawork, preserves standalone Ultrawork
Local-only: Clears state files in
```
.omc/state/
```
directory
Resume-friendly: Autopilot state is preserved for seamless resume
Team-aware: Detects native Claude Code teams and performs graceful shutdown

MCP Worker Cleanup

When cancelling modes that may have spawned MCP workers (team bridge daemons), the cancel skill should also:

Check for active MCP workers: Look for heartbeat files at
```
.omc/state/team-bridge/{team}/*.heartbeat.json
```
Send shutdown signals: Write shutdown signal files for each active worker

Kill tmux sessions: Run

tmux kill-session -t omc-team-{team}-{worker}

for each worker

Clean up heartbeat files: Remove all heartbeat files for the team
Clean up shadow registry: Remove
```
.omc/state/team-mcp-workers.json
```

Force Clear Addition

When

--force

is used, also clean up:

bash

rm -rf .omc/state/team-bridge/       # Heartbeat files
rm -f .omc/state/team-mcp-workers.json  # Shadow registry
# Kill all omc-team-* tmux sessions
tmux list-sessions -F '#{session_name}' 2>/dev/null | grep '^omc-team-' | while read s; do tmux kill-session -t "$s" 2>/dev/null; done

cancel

NPX Install

Tags

SKILL.md Content

Cancel Skill

What It Does

Usage

Auto-Detection

Force Clear All

Implementation Steps

1. Parse Arguments

2. Detect Active Modes

3A. Force Mode (if --force or --all)

3B. Smart Cancellation (default)

If Team Active (Claude Code native)

If Autopilot Active

If Ralph Active (but not Autopilot)

If Ultrawork Active (standalone, not linked)

If UltraQA Active (standalone)

No Active Modes

Implementation Notes

Messages Reference

What Gets Preserved

Notes

MCP Worker Cleanup

Force Clear Addition