oh-my-claude-sisyphus 2.6.1 → 3.0.0

package/scripts/persistent-mode.sh

@@ -21,22 +21,22 @@ fi
 
 # Check for active ultrawork state
 ULTRAWORK_STATE=""
-if [ -f "$DIRECTORY/.sisyphus/ultrawork-state.json" ]; then
-  ULTRAWORK_STATE=$(cat "$DIRECTORY/.sisyphus/ultrawork-state.json" 2>/dev/null)
+if [ -f "$DIRECTORY/.omc/ultrawork-state.json" ]; then
+  ULTRAWORK_STATE=$(cat "$DIRECTORY/.omc/ultrawork-state.json" 2>/dev/null)
 elif [ -f "$HOME/.claude/ultrawork-state.json" ]; then
   ULTRAWORK_STATE=$(cat "$HOME/.claude/ultrawork-state.json" 2>/dev/null)
 fi
 
 # Check for active ralph loop
 RALPH_STATE=""
-if [ -f "$DIRECTORY/.sisyphus/ralph-state.json" ]; then
-  RALPH_STATE=$(cat "$DIRECTORY/.sisyphus/ralph-state.json" 2>/dev/null)
+if [ -f "$DIRECTORY/.omc/ralph-state.json" ]; then
+  RALPH_STATE=$(cat "$DIRECTORY/.omc/ralph-state.json" 2>/dev/null)
 fi
 
 # Check for verification state (oracle verification)
 VERIFICATION_STATE=""
-if [ -f "$DIRECTORY/.sisyphus/ralph-verification.json" ]; then
-  VERIFICATION_STATE=$(cat "$DIRECTORY/.sisyphus/ralph-verification.json" 2>/dev/null)
+if [ -f "$DIRECTORY/.omc/ralph-verification.json" ]; then
+  VERIFICATION_STATE=$(cat "$DIRECTORY/.omc/ralph-verification.json" 2>/dev/null)
 fi
 
 # Check for incomplete todos
@@ -58,7 +58,7 @@ if [ -d "$TODOS_DIR" ]; then
 fi
 
 # Check project todos as well
-for todo_path in "$DIRECTORY/.sisyphus/todos.json" "$DIRECTORY/.claude/todos.json"; do
+for todo_path in "$DIRECTORY/.omc/todos.json" "$DIRECTORY/.claude/todos.json"; do
   if [ -f "$todo_path" ]; then
     if command -v jq &> /dev/null; then
       COUNT=$(jq 'if type == "array" then [.[] | select(.status != "completed" and .status != "cancelled")] | length else 0 end' "$todo_path" 2>/dev/null || echo "0")
@@ -106,11 +106,22 @@ EOF
     if [ "$ITERATION" -lt "$MAX_ITER" ]; then
       # Increment iteration
       NEW_ITER=$((ITERATION + 1))
-      echo "$RALPH_STATE" | jq ".iteration = $NEW_ITER" > "$DIRECTORY/.sisyphus/ralph-state.json" 2>/dev/null
+      echo "$RALPH_STATE" | jq ".iteration = $NEW_ITER" > "$DIRECTORY/.omc/ralph-state.json" 2>/dev/null
 
-      cat << EOF
+      # Check if ultrawork is linked (auto-activated with ralph)
+      LINKED_ULTRAWORK=$(echo "$RALPH_STATE" | jq -r '.linked_ultrawork // false' 2>/dev/null)
+
+      if [ "$LINKED_ULTRAWORK" = "true" ]; then
+        # Combined ralph+ultrawork message with parallel execution rules
+        cat << EOF
+{"continue": false, "reason": "<ralph-ultrawork-continuation>\n\n[RALPH + ULTRAWORK - ITERATION $NEW_ITER/$MAX_ITER]\n\nYour previous attempt did not output the completion promise. The work is NOT done yet.\n\n## ULTRAWORK RULES (ACTIVE)\n- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially\n- **BACKGROUND FIRST**: Use Task(run_in_background=true) for long operations\n- **DELEGATE**: Route tasks to specialist agents immediately\n- **SMART ROUTING**: Use haiku for lookups, sonnet for standard work, opus for complex analysis\n- **TODO**: Track EVERY step. Mark complete IMMEDIATELY.\n\n## COMPLETION REQUIREMENTS\n1. Review your progress and the original task\n2. Check your todo list - are ALL items marked complete?\n3. Continue from where you left off using PARALLEL execution\n4. Get Architect verification when ready\n5. When FULLY complete AND verified, output: <promise>$PROMISE</promise>\n6. Do NOT stop until the task is truly done\n\nOriginal task: $PROMPT\n\n</ralph-ultrawork-continuation>\n\n---\n"}
+EOF
+      else
+        # Standard ralph-only message
+        cat << EOF
 {"continue": false, "reason": "<ralph-loop-continuation>\n\n[RALPH LOOP - ITERATION $NEW_ITER/$MAX_ITER]\n\nYour previous attempt did not output the completion promise. The work is NOT done yet.\n\nCRITICAL INSTRUCTIONS:\n1. Review your progress and the original task\n2. Check your todo list - are ALL items marked complete?\n3. Continue from where you left off\n4. When FULLY complete, output: <promise>$PROMISE</promise>\n5. Do NOT stop until the task is truly done\n\nOriginal task: $PROMPT\n\n</ralph-loop-continuation>\n\n---\n"}
 EOF
+      fi
       exit 0
     fi
   fi
@@ -277,7 +288,7 @@ if [ -n "$ULTRAWORK_STATE" ] && [ "$INCOMPLETE_COUNT" -gt 0 ]; then
 
     # Update state file (best effort)
     if command -v jq &> /dev/null; then
-      echo "$ULTRAWORK_STATE" | jq ".reinforcement_count = $NEW_COUNT | .last_checked_at = \"$(date -Iseconds)\"" > "$DIRECTORY/.sisyphus/ultrawork-state.json" 2>/dev/null
+      echo "$ULTRAWORK_STATE" | jq ".reinforcement_count = $NEW_COUNT | .last_checked_at = \"$(date -Iseconds)\"" > "$DIRECTORY/.omc/ultrawork-state.json" 2>/dev/null
     fi
 
     cat << EOF

package/scripts/plugin-setup.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * Plugin Post-Install Setup
+ *
+ * Configures HUD statusline when plugin is installed.
+ * This runs after `claude plugin install oh-my-claudecode@oh-my-claudecode`
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, chmodSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const CLAUDE_DIR = join(homedir(), '.claude');
+const HUD_DIR = join(CLAUDE_DIR, 'hud');
+const SETTINGS_FILE = join(CLAUDE_DIR, 'settings.json');
+
+console.log('[Sisyphus] Running post-install setup...');
+
+// 1. Create HUD directory
+if (!existsSync(HUD_DIR)) {
+  mkdirSync(HUD_DIR, { recursive: true });
+}
+
+// 2. Create HUD wrapper script
+const hudScriptPath = join(HUD_DIR, 'sisyphus-hud.mjs');
+const hudScript = `#!/usr/bin/env node
+/**
+ * Sisyphus HUD - Statusline Script
+ * Wrapper that imports from plugin cache or development paths
+ */
+
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+async function main() {
+  const home = homedir();
+
+  // 1. Try plugin cache first (preferred for 3.0.0+)
+  const pluginCacheBase = join(home, ".claude/plugins/cache/oh-my-claudecode/oh-my-claudecode");
+  if (existsSync(pluginCacheBase)) {
+    try {
+      const versions = readdirSync(pluginCacheBase);
+      if (versions.length > 0) {
+        const latestVersion = versions.sort().reverse()[0];
+        const pluginPath = join(pluginCacheBase, latestVersion, "dist/hud/index.js");
+        if (existsSync(pluginPath)) {
+          await import(pluginPath);
+          return;
+        }
+      }
+    } catch { /* continue */ }
+  }
+
+  // 2. Development paths
+  const devPaths = [
+    join(home, "Workspace/oh-my-claudecode/dist/hud/index.js"),
+    join(home, "workspace/oh-my-claudecode/dist/hud/index.js"),
+  ];
+
+  for (const devPath of devPaths) {
+    if (existsSync(devPath)) {
+      try {
+        await import(devPath);
+        return;
+      } catch { /* continue */ }
+    }
+  }
+
+  // 3. Fallback
+  console.log("[SISYPHUS] active");
+}
+
+main();
+`;
+
+writeFileSync(hudScriptPath, hudScript);
+try {
+  chmodSync(hudScriptPath, 0o755);
+} catch { /* Windows doesn't need this */ }
+console.log('[Sisyphus] Installed HUD wrapper script');
+
+// 3. Configure settings.json
+try {
+  let settings = {};
+  if (existsSync(SETTINGS_FILE)) {
+    settings = JSON.parse(readFileSync(SETTINGS_FILE, 'utf-8'));
+  }
+
+  // Add statusLine if not configured
+  if (!settings.statusLine) {
+    settings.statusLine = {
+      type: 'command',
+      command: `node ${hudScriptPath}`
+    };
+    writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+    console.log('[Sisyphus] Configured HUD statusLine in settings.json');
+  } else {
+    console.log('[Sisyphus] statusLine already configured, skipping');
+  }
+} catch (e) {
+  console.log('[Sisyphus] Warning: Could not configure settings.json:', e.message);
+}
+
+console.log('[Sisyphus] Setup complete! Restart Claude Code to activate HUD.');

package/scripts/pre-tool-enforcer.mjs

@@ -38,7 +38,7 @@ function getTodoStatus(directory) {
 
   // Check project-local todos
   const localPaths = [
-    join(directory, '.sisyphus', 'todos.json'),
+    join(directory, '.omc', 'todos.json'),
     join(directory, '.claude', 'todos.json')
   ];
 

package/scripts/pre-tool-enforcer.sh

@@ -19,7 +19,7 @@ toolName=$(extract_json_field "toolName" "unknown")
 directory=$(extract_json_field "directory" "")
 
 # Try to get todo count from todo list file (if exists)
-todo_file="${directory}/.sisyphus/todos.json"
+todo_file="${directory}/.omc/todos.json"
 todo_status=""
 if [[ -f "$todo_file" ]] && command -v jq &> /dev/null; then
     pending=$(jq -r '[.todos[] | select(.status == "pending")] | length' "$todo_file" 2>/dev/null || echo "0")

package/scripts/session-start.mjs

@@ -46,6 +46,33 @@ function countIncompleteTodos(todosDir) {
   return count;
 }
 
+// Check if HUD is properly installed
+function checkHudInstallation() {
+  const hudScript = join(homedir(), '.claude', 'hud', 'sisyphus-hud.mjs');
+  const settingsFile = join(homedir(), '.claude', 'settings.json');
+
+  // Check if HUD script exists
+  if (!existsSync(hudScript)) {
+    return { installed: false, reason: 'HUD script missing' };
+  }
+
+  // Check if statusLine is configured
+  try {
+    if (existsSync(settingsFile)) {
+      const settings = JSON.parse(readFileSync(settingsFile, 'utf-8'));
+      if (!settings.statusLine) {
+        return { installed: false, reason: 'statusLine not configured' };
+      }
+    } else {
+      return { installed: false, reason: 'settings.json missing' };
+    }
+  } catch {
+    return { installed: false, reason: 'Could not read settings' };
+  }
+
+  return { installed: true };
+}
+
 // Main
 async function main() {
   try {
@@ -56,8 +83,16 @@ async function main() {
     const directory = data.directory || process.cwd();
     const messages = [];
 
+    // Check HUD installation (one-time setup guidance)
+    const hudCheck = checkHudInstallation();
+    if (!hudCheck.installed) {
+      messages.push(`<system-reminder>
+[Sisyphus] HUD not configured (${hudCheck.reason}). Run /hud setup then restart Claude Code.
+</system-reminder>`);
+    }
+
     // Check for ultrawork state
-    const ultraworkState = readJsonFile(join(directory, '.sisyphus', 'ultrawork-state.json'))
+    const ultraworkState = readJsonFile(join(directory, '.omc', 'ultrawork-state.json'))
       || readJsonFile(join(homedir(), '.claude', 'ultrawork-state.json'));
 
     if (ultraworkState?.active) {
@@ -77,7 +112,7 @@ Continue working in ultrawork mode until all tasks are complete.
     }
 
     // Check for ralph loop state
-    const ralphState = readJsonFile(join(directory, '.sisyphus', 'ralph-state.json'));
+    const ralphState = readJsonFile(join(directory, '.omc', 'ralph-state.json'));
     if (ralphState?.active) {
       messages.push(`<session-restore>
 
@@ -114,7 +149,7 @@ Please continue working on these tasks.
     }
 
     // Check for notepad Priority Context
-    const notepadPath = join(directory, '.sisyphus', 'notepad.md');
+    const notepadPath = join(directory, '.omc', 'notepad.md');
     if (existsSync(notepadPath)) {
       try {
         const notepadContent = readFileSync(notepadPath, 'utf-8');

package/scripts/skill-injector.mjs

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+
+/**
+ * Skill Injector Hook (UserPromptSubmit)
+ * Injects relevant learned skills into context based on prompt triggers.
+ *
+ * STANDALONE SCRIPT - does not import from dist/
+ * Follows pattern of keyword-detector.mjs and session-start.mjs
+ */
+
+import { existsSync, readdirSync, readFileSync, realpathSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Constants
+const USER_SKILLS_DIR = join(homedir(), '.claude', 'skills', 'omc-learned');
+const PROJECT_SKILLS_SUBDIR = '.omc/skills';
+const SKILL_EXTENSION = '.md';
+const MAX_SKILLS_PER_SESSION = 5;
+
+// Session cache to avoid re-injecting same skills
+const injectedCache = new Map();
+
+// Read all stdin
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+// Parse YAML frontmatter from skill file
+function parseSkillFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) return null;
+
+  const yamlContent = match[1];
+  const body = match[2].trim();
+
+  // Simple YAML parsing for triggers
+  const triggers = [];
+  const triggerMatch = yamlContent.match(/triggers:\s*\n((?:\s+-\s*.+\n?)*)/);
+  if (triggerMatch) {
+    const lines = triggerMatch[1].split('\n');
+    for (const line of lines) {
+      const itemMatch = line.match(/^\s+-\s*["']?([^"'\n]+)["']?\s*$/);
+      if (itemMatch) triggers.push(itemMatch[1].trim().toLowerCase());
+    }
+  }
+
+  // Extract name
+  const nameMatch = yamlContent.match(/name:\s*["']?([^"'\n]+)["']?/);
+  const name = nameMatch ? nameMatch[1].trim() : 'Unnamed Skill';
+
+  return { name, triggers, content: body };
+}
+
+// Find all skill files
+function findSkillFiles(directory) {
+  const candidates = [];
+  const seenPaths = new Set();
+
+  // Project-level skills (higher priority)
+  const projectDir = join(directory, PROJECT_SKILLS_SUBDIR);
+  if (existsSync(projectDir)) {
+    try {
+      const files = readdirSync(projectDir, { withFileTypes: true });
+      for (const file of files) {
+        if (file.isFile() && file.name.endsWith(SKILL_EXTENSION)) {
+          const fullPath = join(projectDir, file.name);
+          try {
+            const realPath = realpathSync(fullPath);
+            if (!seenPaths.has(realPath)) {
+              seenPaths.add(realPath);
+              candidates.push({ path: fullPath, scope: 'project' });
+            }
+          } catch {
+            // Ignore symlink resolution errors
+          }
+        }
+      }
+    } catch {
+      // Ignore directory read errors
+    }
+  }
+
+  // User-level skills
+  if (existsSync(USER_SKILLS_DIR)) {
+    try {
+      const files = readdirSync(USER_SKILLS_DIR, { withFileTypes: true });
+      for (const file of files) {
+        if (file.isFile() && file.name.endsWith(SKILL_EXTENSION)) {
+          const fullPath = join(USER_SKILLS_DIR, file.name);
+          try {
+            const realPath = realpathSync(fullPath);
+            if (!seenPaths.has(realPath)) {
+              seenPaths.add(realPath);
+              candidates.push({ path: fullPath, scope: 'user' });
+            }
+          } catch {
+            // Ignore symlink resolution errors
+          }
+        }
+      }
+    } catch {
+      // Ignore directory read errors
+    }
+  }
+
+  return candidates;
+}
+
+// Find matching skills by trigger keywords
+function findMatchingSkills(prompt, directory, sessionId) {
+  const promptLower = prompt.toLowerCase();
+  const candidates = findSkillFiles(directory);
+  const matches = [];
+
+  // Get or create session cache
+  if (!injectedCache.has(sessionId)) {
+    injectedCache.set(sessionId, new Set());
+  }
+  const alreadyInjected = injectedCache.get(sessionId);
+
+  for (const candidate of candidates) {
+    // Skip if already injected this session
+    if (alreadyInjected.has(candidate.path)) continue;
+
+    try {
+      const content = readFileSync(candidate.path, 'utf-8');
+      const skill = parseSkillFrontmatter(content);
+      if (!skill) continue;
+
+      // Check if any trigger matches
+      let score = 0;
+      for (const trigger of skill.triggers) {
+        if (promptLower.includes(trigger)) {
+          score += 10;
+        }
+      }
+
+      if (score > 0) {
+        matches.push({
+          path: candidate.path,
+          name: skill.name,
+          content: skill.content,
+          score,
+          scope: candidate.scope
+        });
+      }
+    } catch {
+      // Ignore file read errors
+    }
+  }
+
+  // Sort by score (descending) and limit
+  matches.sort((a, b) => b.score - a.score);
+  const selected = matches.slice(0, MAX_SKILLS_PER_SESSION);
+
+  // Mark as injected
+  for (const skill of selected) {
+    alreadyInjected.add(skill.path);
+  }
+
+  return selected;
+}
+
+// Format skills for injection
+function formatSkillsMessage(skills) {
+  const lines = [
+    '<mnemosyne>',
+    '',
+    '## Relevant Learned Skills',
+    '',
+    'The following skills from previous sessions may help:',
+    ''
+  ];
+
+  for (const skill of skills) {
+    lines.push(`### ${skill.name} (${skill.scope})`);
+    lines.push('');
+    lines.push(skill.content);
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+  }
+
+  lines.push('</mnemosyne>');
+  return lines.join('\n');
+}
+
+// Main
+async function main() {
+  try {
+    const input = await readStdin();
+    if (!input.trim()) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    let data = {};
+    try { data = JSON.parse(input); } catch { /* ignore parse errors */ }
+
+    const prompt = data.prompt || '';
+    const sessionId = data.sessionId || 'unknown';
+    const directory = data.cwd || process.cwd();
+
+    // Skip if no prompt
+    if (!prompt) {
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+
+    const matchingSkills = findMatchingSkills(prompt, directory, sessionId);
+
+    if (matchingSkills.length > 0) {
+      console.log(JSON.stringify({
+        continue: true,
+        message: formatSkillsMessage(matchingSkills)
+      }));
+    } else {
+      console.log(JSON.stringify({ continue: true }));
+    }
+  } catch (error) {
+    // On any error, allow continuation
+    console.log(JSON.stringify({ continue: true }));
+  }
+}
+
+main();

package/scripts/uninstall.sh

@@ -90,10 +90,10 @@ rm -f "$CLAUDE_CONFIG_DIR/hooks/silent-auto-update.sh"
 
 # Remove version, state, and config files
 echo -e "${BLUE}Removing state and config files...${NC}"
-rm -f "$CLAUDE_CONFIG_DIR/.sisyphus-version.json"
-rm -f "$CLAUDE_CONFIG_DIR/.sisyphus-silent-update.json"
-rm -f "$CLAUDE_CONFIG_DIR/.sisyphus-update.log"
-rm -f "$CLAUDE_CONFIG_DIR/.sisyphus-config.json"
+rm -f "$CLAUDE_CONFIG_DIR/.omc-version.json"
+rm -f "$CLAUDE_CONFIG_DIR/.omc-silent-update.json"
+rm -f "$CLAUDE_CONFIG_DIR/.omc-update.log"
+rm -f "$CLAUDE_CONFIG_DIR/.omc-config.json"
 
 # Remove hook configurations from settings.json
 SETTINGS_FILE="$CLAUDE_CONFIG_DIR/settings.json"
@@ -154,11 +154,11 @@ else
     fi
 fi
 
-# Remove .sisyphus directory if it exists (plans, notepads, drafts)
-if [ -d "$CLAUDE_CONFIG_DIR/../.sisyphus" ] || [ -d ".sisyphus" ]; then
-    echo -e "${YELLOW}Note: .sisyphus directory (plans/notepads) was not removed.${NC}"
+# Remove .omc directory if it exists (plans, notepads, drafts)
+if [ -d "$CLAUDE_CONFIG_DIR/../.omc" ] || [ -d ".omc" ]; then
+    echo -e "${YELLOW}Note: .omc directory (plans/notepads) was not removed.${NC}"
     echo "  To remove project plans and notepads, run:"
-    echo "    rm -rf .sisyphus"
+    echo "    rm -rf .omc"
 fi
 
 echo ""

package/skills/analyze/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: analyze
+description: Deep analysis and investigation
+user-invocable: true
+---
+
+# Deep Analysis Mode
+
+[ANALYSIS MODE ACTIVATED]
+
+## Objective
+
+Conduct thorough analysis of the specified target (code, architecture, issue, bug, performance bottleneck, security concern).
+
+## Approach
+
+1. **Gather Context**
+   - Read relevant files
+   - Check git history if relevant
+   - Review related issues/PRs if applicable
+
+2. **Analyze Systematically**
+   - Identify patterns and antipatterns
+   - Trace execution flows
+   - Map dependencies and relationships
+   - Check for edge cases
+
+3. **Synthesize Findings**
+   - Root cause (for bugs)
+   - Design decisions and tradeoffs (for architecture)
+   - Bottlenecks and hotspots (for performance)
+   - Vulnerabilities and risks (for security)
+
+4. **Provide Recommendations**
+   - Concrete, actionable next steps
+   - Prioritized by impact
+   - Consider maintainability and technical debt
+
+## Output Format
+
+Present findings clearly:
+- **Summary** (2-3 sentences)
+- **Key Findings** (bulleted list)
+- **Analysis** (detailed explanation)
+- **Recommendations** (prioritized)
+
+Stay objective. Cite file paths and line numbers. No speculation without evidence.

package/skills/cancel-ralph/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: cancel-ralph
+description: Cancel active Ralph (and linked ultrawork if auto-activated)
+user-invocable: true
+---
+
+# Cancel Ralph
+
+[RALPH CANCELLED]
+
+Ralph has been cancelled. You MUST now deactivate the state files.
+
+## MANDATORY ACTION
+
+Execute this command to fully cancel ALL persistent modes:
+
+```bash
+mkdir -p .omc ~/.claude && \
+echo '{"active": false, "cancelled_at": "'$(date -Iseconds)'", "reason": "User cancelled via /cancel-ralph"}' > .omc/ralph-state.json && \
+echo '{"active": false, "cancelled_at": "'$(date -Iseconds)'", "reason": "User cancelled via /cancel-ralph", "linked_to_ralph": false}' > .omc/ultrawork-state.json && \
+echo '{"active": false, "cancelled_at": "'$(date -Iseconds)'", "reason": "User cancelled via /cancel-ralph"}' > .omc/ralph-plan-state.json && \
+echo '{"active": false, "cancelled_at": "'$(date -Iseconds)'", "reason": "User cancelled via /cancel-ralph"}' > ~/.claude/ralph-state.json && \
+echo '{"active": false, "cancelled_at": "'$(date -Iseconds)'", "reason": "User cancelled via /cancel-ralph"}' > ~/.claude/ultrawork-state.json && \
+rm -f .omc/ralph-verification.json
+```
+
+After running this command, you are free to stop working. The persistent mode hook will no longer force continuation.
+
+## What Was Cancelled
+
+- **Ralph**: Self-referential completion loop
+- **Ultrawork**: Parallel execution mode (auto-activated with Ralph by default)
+- **Ralph Plan**: Iterative planning loop (if active via /ralplan)
+- **Verification State**: Any pending architect verification
+
+## Note on Linked Modes
+
+Since v3.0, Ralph automatically activates Ultrawork for parallel execution. When you cancel Ralph, the linked Ultrawork is also cancelled. If you started Ultrawork separately (not via Ralph), use `/cancel-ultrawork` to cancel it independently.
+
+## To Start Fresh
+
+- `/ralph "task"` - Start ralph with ultrawork (default)
+- `/ultrawork "task"` - Start ultrawork only (standalone)

package/skills/cancel-ultraqa/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: cancel-ultraqa
+description: Cancel active UltraQA cycling workflow
+user-invocable: true
+---
+
+# Cancel UltraQA
+
+[ULTRAQA CANCELLED]
+
+The UltraQA cycling workflow has been cancelled. Clearing state file.
+
+## MANDATORY ACTION
+
+Execute this command to cancel UltraQA:
+
+```bash
+mkdir -p .sisyphus && echo '{"active": false, "cancelled_at": "'$(date -Iseconds)'", "reason": "User cancelled via /cancel-ultraqa"}' > .omc/ultraqa-state.json
+```
+
+After running this command, the QA cycling will stop.
+
+## To Start Fresh
+
+- `/ultraqa --tests` - Run until all tests pass
+- `/ultraqa --build` - Run until build succeeds
+- `/ultraqa --lint` - Run until no lint errors
+- `/ultraqa --typecheck` - Run until no type errors
+- `/ultraqa --custom "pattern"` - Run until pattern matches