oh-my-claude-sisyphus 3.7.16 → 3.8.1

package/docs/CLAUDE.md

@@ -309,6 +309,89 @@ Always use `oh-my-claudecode:` prefix when calling via Task tool.
 | Data analysis/stats | `scientist` | sonnet |
 | Quick data inspection | `scientist-low` | haiku |
 | Complex ML/hypothesis | `scientist-high` | opus |
+| Find symbol references | `explore-high` | opus |
+| Get file/workspace symbol outline | `explore` | haiku |
+| Structural code pattern search | `explore` | haiku |
+| Structural code transformation | `executor-high` | opus |
+| Project-wide type checking | `build-fixer` | sonnet |
+| Check single file for errors | `executor-low` | haiku |
+| Data analysis / computation | `scientist` | sonnet |
+
+### MCP Tools & Agent Capabilities
+
+*Source of truth: `src/agents/definitions.ts`*
+
+#### Tool Inventory
+
+| Tool | Category | Purpose | Assigned to Agents? |
+|------|----------|---------|---------------------|
+| `lsp_hover` | LSP | Get type info and documentation at a code position | NO (orchestrator-direct) |
+| `lsp_goto_definition` | LSP | Jump to where a symbol is defined | NO (orchestrator-direct) |
+| `lsp_find_references` | LSP | Find all usages of a symbol across the codebase | YES (`explore-high` only) |
+| `lsp_document_symbols` | LSP | Get outline of all symbols in a file | YES |
+| `lsp_workspace_symbols` | LSP | Search for symbols by name across the workspace | YES |
+| `lsp_diagnostics` | LSP | Get errors, warnings, and hints for a file | YES |
+| `lsp_diagnostics_directory` | LSP | Project-level type checking (tsc --noEmit or LSP) | YES |
+| `lsp_prepare_rename` | LSP | Check if a symbol can be renamed | NO (orchestrator-direct) |
+| `lsp_rename` | LSP | Rename a symbol across the entire project | NO (orchestrator-direct) |
+| `lsp_code_actions` | LSP | Get available refactorings and quick fixes | NO (orchestrator-direct) |
+| `lsp_code_action_resolve` | LSP | Get full edit details for a code action | NO (orchestrator-direct) |
+| `lsp_servers` | LSP | List available language servers and install status | NO (orchestrator-direct) |
+| `ast_grep_search` | AST | Pattern-based structural code search using AST | YES |
+| `ast_grep_replace` | AST | Pattern-based structural code transformation | YES (`executor-high` only) |
+| `python_repl` | Data | Persistent Python REPL for data analysis and computation | YES |
+
+#### Agent Tool Matrix (MCP Tools Only)
+
+| Agent | LSP Diagnostics | LSP Dir Diagnostics | LSP Symbols | LSP References | AST Search | AST Replace | Python REPL |
+|-------|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
+| `explore` | - | - | doc + workspace | - | yes | - | - |
+| `explore-medium` | - | - | doc + workspace | - | yes | - | - |
+| `explore-high` | - | - | doc + workspace | yes | yes | - | - |
+| `architect-low` | yes | - | - | - | - | - | - |
+| `architect-medium` | yes | yes | - | - | yes | - | - |
+| `architect` | yes | yes | - | - | yes | - | - |
+| `executor-low` | yes | - | - | - | - | - | - |
+| `executor` | yes | yes | - | - | - | - | - |
+| `executor-high` | yes | yes | - | - | yes | yes | - |
+| `build-fixer` | yes | yes | - | - | - | - | - |
+| `build-fixer-low` | yes | yes | - | - | - | - | - |
+| `tdd-guide` | yes | - | - | - | - | - | - |
+| `tdd-guide-low` | yes | - | - | - | - | - | - |
+| `code-reviewer` | yes | - | - | - | yes | - | - |
+| `code-reviewer-low` | yes | - | - | - | - | - | - |
+| `qa-tester` | yes | - | - | - | - | - | - |
+| `qa-tester-high` | yes | - | - | - | - | - | - |
+| `scientist-low` | - | - | - | - | - | - | yes |
+| `scientist` | - | - | - | - | - | - | yes |
+| `scientist-high` | - | - | - | - | - | - | yes |
+
+#### Unassigned Tools (Orchestrator-Direct)
+
+The following 7 MCP tools are NOT assigned to any agent. Use directly when needed:
+
+| Tool | When to Use Directly |
+|------|---------------------|
+| `lsp_hover` | Quick type lookups during conversation |
+| `lsp_goto_definition` | Navigating to symbol definitions during analysis |
+| `lsp_prepare_rename` | Checking rename feasibility before deciding on approach |
+| `lsp_rename` | Safe rename operations (returns edit preview, does not auto-apply) |
+| `lsp_code_actions` | Discovering available refactorings |
+| `lsp_code_action_resolve` | Getting details of a specific code action |
+| `lsp_servers` | Checking language server availability |
+
+For complex rename or refactoring tasks requiring implementation, delegate to `executor-high` which can use `ast_grep_replace` for structural transformations.
+
+#### Tool Selection Guidance
+
+- **Need file symbol outline or workspace search?** Use `lsp_document_symbols`/`lsp_workspace_symbols` via `explore`, `explore-medium`, or `explore-high`
+- **Need to find all usages of a symbol?** Use `lsp_find_references` via `explore-high` (only agent with it)
+- **Need structural code patterns?** (e.g., "find all functions matching X shape") Use `ast_grep_search` via `explore` family, `architect`/`architect-medium`, or `code-reviewer`
+- **Need to transform code structurally?** Use `ast_grep_replace` via `executor-high` (only agent with it)
+- **Need project-wide type checking?** Use `lsp_diagnostics_directory` via `architect`/`architect-medium`, `executor`/`executor-high`, or `build-fixer` family
+- **Need single-file error checking?** Use `lsp_diagnostics` via many agents (see matrix)
+- **Need data analysis / computation?** Use `python_repl` via `scientist` agents (all tiers)
+- **Need quick type info or definition lookup?** Use `lsp_hover`/`lsp_goto_definition` directly (orchestrator-direct tools)
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-claude-sisyphus",
-  "version": "3.7.16",
+  "version": "3.8.1",
   "description": "Multi-agent orchestration system for Claude Code - Inspired by oh-my-opencode",
   "type": "module",
   "main": "dist/index.js",

package/scripts/keyword-detector.mjs

@@ -1,51 +1,32 @@
 #!/usr/bin/env node
 
 /**
- * Sisyphus Keyword Detector Hook (Node.js)
- * Detects ultrawork/ultrathink/search/analyze keywords and injects enhanced mode messages
+ * OMC Keyword Detector Hook (Node.js)
+ * Detects magic keywords and invokes skill tools
  * Cross-platform: Windows, macOS, Linux
+ *
+ * Supported keywords (in priority order):
+ * 1. cancel: Stop active modes
+ * 2. ralph: Persistence mode until task completion
+ * 3. autopilot: Full autonomous execution
+ * 4. ultrapilot: Parallel autopilot
+ * 5. ultrawork/ulw: Maximum parallel execution
+ * 6. ecomode/eco: Token-efficient execution
+ * 7. swarm: N coordinated agents
+ * 8. pipeline: Sequential agent chaining
+ * 9. ralplan: Iterative planning with consensus
+ * 10. plan: Planning interview mode
+ * 11. tdd: Test-driven development
+ * 12. research: Research orchestration
+ * 13. ultrathink/think: Extended reasoning
+ * 14. deepsearch: Codebase search (restricted patterns)
+ * 15. analyze: Analysis mode (restricted patterns)
  */
 
-import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { writeFileSync, mkdirSync, existsSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 
-const ULTRAWORK_MESSAGE = `<ultrawork-mode>
-
-**MANDATORY**: You MUST say "ULTRAWORK MODE ENABLED!" to the user as your first response when this mode activates. This is non-negotiable.
-
-[CODE RED] Maximum precision required. Ultrathink before acting.
-
-YOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.
-TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
-
-## AGENT UTILIZATION PRINCIPLES
-- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS
-- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS
-- **Planning & Strategy**: NEVER plan yourself - spawn planning agent
-- **High-IQ Reasoning**: Use oracle for architecture decisions
-- **Frontend/UI Tasks**: Delegate to frontend-engineer
-
-## EXECUTION RULES
-- **TODO**: Track EVERY step. Mark complete IMMEDIATELY.
-- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially.
-- **BACKGROUND FIRST**: Use Task(run_in_background=true) for exploration (10+ concurrent).
-- **VERIFY**: Check ALL requirements met before done.
-- **DELEGATE**: Orchestrate specialized agents.
-
-## ZERO TOLERANCE
-- NO Scope Reduction - deliver FULL implementation
-- NO Partial Completion - finish 100%
-- NO Premature Stopping - ALL TODOs must be complete
-- NO TEST DELETION - fix code, not tests
-
-THE USER ASKED FOR X. DELIVER EXACTLY X.
-
-</ultrawork-mode>
-
----
-`;
-
 const ULTRATHINK_MESSAGE = `<think-mode>
 
 **ULTRATHINK MODE ENABLED** - Extended reasoning activated.
@@ -63,34 +44,6 @@ Use your extended thinking capabilities to provide the most thorough and well-re
 ---
 `;
 
-const SEARCH_MESSAGE = `<search-mode>
-MAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:
-- explore agents (codebase patterns, file structures)
-- librarian agents (remote repos, official docs, GitHub examples)
-Plus direct tools: Grep, Glob
-NEVER stop at first result - be exhaustive.
-</search-mode>
-
----
-`;
-
-const ANALYZE_MESSAGE = `<analyze-mode>
-ANALYSIS MODE. Gather context before diving deep:
-
-CONTEXT GATHERING (parallel):
-- 1-2 explore agents (codebase patterns, implementations)
-- 1-2 librarian agents (if external library involved)
-- Direct tools: Grep, Glob, LSP for targeted searches
-
-IF COMPLEX (architecture, multi-system, debugging after 2+ failures):
-- Consult oracle agent for strategic guidance
-
-SYNTHESIZE findings before proceeding.
-</analyze-mode>
-
----
-`;
-
 // Read all stdin
 async function readStdin() {
   const chunks = [];
@@ -127,8 +80,8 @@ function removeCodeBlocks(text) {
     .replace(/`[^`]+`/g, '');
 }
 
-// Create ultrawork state file
-function activateUltraworkState(directory, prompt) {
+// Create state file for a mode
+function activateState(directory, prompt, stateName) {
   const state = {
     active: true,
     started_at: new Date().toISOString(),
@@ -142,14 +95,43 @@ function activateUltraworkState(directory, prompt) {
   if (!existsSync(localDir)) {
     try { mkdirSync(localDir, { recursive: true }); } catch {}
   }
-  try { writeFileSync(join(localDir, 'ultrawork-state.json'), JSON.stringify(state, null, 2)); } catch {}
+  try { writeFileSync(join(localDir, `${stateName}-state.json`), JSON.stringify(state, null, 2)); } catch {}
 
   // Write to global .omc/state directory
   const globalDir = join(homedir(), '.omc', 'state');
   if (!existsSync(globalDir)) {
     try { mkdirSync(globalDir, { recursive: true }); } catch {}
   }
-  try { writeFileSync(join(globalDir, 'ultrawork-state.json'), JSON.stringify(state, null, 2)); } catch {}
+  try { writeFileSync(join(globalDir, `${stateName}-state.json`), JSON.stringify(state, null, 2)); } catch {}
+}
+
+/**
+ * Clear state files for cancel operation
+ */
+function clearStateFiles(directory, modeNames) {
+  for (const name of modeNames) {
+    const localPath = join(directory, '.omc', 'state', `${name}-state.json`);
+    const globalPath = join(homedir(), '.omc', 'state', `${name}-state.json`);
+    try { if (existsSync(localPath)) unlinkSync(localPath); } catch {}
+    try { if (existsSync(globalPath)) unlinkSync(globalPath); } catch {}
+  }
+}
+
+/**
+ * Create a skill invocation message that tells Claude to use the Skill tool
+ */
+function createSkillInvocation(skillName, originalPrompt, args = '') {
+  const argsSection = args ? `\nArguments: ${args}` : '';
+  return `[MAGIC KEYWORD: ${skillName.toUpperCase()}]
+
+You MUST invoke the skill using the Skill tool:
+
+Skill: oh-my-claudecode:${skillName}${argsSection}
+
+User request:
+${originalPrompt}
+
+IMPORTANT: Invoke the skill IMMEDIATELY. Do not proceed without loading the skill instructions.`;
 }
 
 // Main
@@ -173,28 +155,166 @@ async function main() {
 
     const cleanPrompt = removeCodeBlocks(prompt).toLowerCase();
 
-    // Check for ultrawork keywords (highest priority)
-    if (/\b(ultrawork|ulw|uw)\b/.test(cleanPrompt)) {
-      activateUltraworkState(directory, prompt);
-      console.log(JSON.stringify({ continue: true, message: ULTRAWORK_MESSAGE }));
+    // Priority order: cancel > ralph > autopilot > ultrapilot > ultrawork > ecomode > swarm > pipeline > ralplan > plan > tdd > research > ultrathink > deepsearch > analyze
+
+    // Priority 1: Cancel (BEFORE other modes - clears states)
+    if (/\b(stop|cancel|abort)\b/i.test(cleanPrompt)) {
+      // Special: clear state files instead of creating them
+      clearStateFiles(directory, ['ralph', 'autopilot', 'ultrapilot', 'ultrawork', 'ecomode', 'swarm', 'pipeline']);
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('cancel', prompt)
+      }));
+      return;
+    }
+
+    // Priority 2: Ralph keywords
+    if (/\b(ralph|don't stop|must complete|until done)\b/i.test(cleanPrompt)) {
+      activateState(directory, prompt, 'ralph');
+      activateState(directory, prompt, 'ultrawork');
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('ralph', prompt)
+      }));
+      return;
+    }
+
+    // Priority 3: Autopilot keywords
+    if (/\b(autopilot|auto pilot|auto-pilot|autonomous|full auto|fullsend)\b/i.test(cleanPrompt) ||
+        /\bbuild\s+me\s+/i.test(cleanPrompt) ||
+        /\bcreate\s+me\s+/i.test(cleanPrompt) ||
+        /\bmake\s+me\s+/i.test(cleanPrompt) ||
+        /\bi\s+want\s+a\s+/i.test(cleanPrompt) ||
+        /\bi\s+want\s+an\s+/i.test(cleanPrompt) ||
+        /\bhandle\s+it\s+all\b/i.test(cleanPrompt) ||
+        /\bend\s+to\s+end\b/i.test(cleanPrompt) ||
+        /\be2e\s+this\b/i.test(cleanPrompt)) {
+      activateState(directory, prompt, 'autopilot');
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('autopilot', prompt)
+      }));
+      return;
+    }
+
+    // Priority 4: Ultrapilot
+    if (/\b(ultrapilot|ultra-pilot)\b/i.test(cleanPrompt) ||
+        /\bparallel\s+build\b/i.test(cleanPrompt) ||
+        /\bswarm\s+build\b/i.test(cleanPrompt)) {
+      activateState(directory, prompt, 'ultrapilot');
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('ultrapilot', prompt)
+      }));
+      return;
+    }
+
+    // Priority 5: Ultrawork keywords
+    if (/\b(ultrawork|ulw|uw)\b/i.test(cleanPrompt)) {
+      activateState(directory, prompt, 'ultrawork');
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('ultrawork', prompt)
+      }));
+      return;
+    }
+
+    // Priority 6: Ecomode keywords (includes "efficient")
+    if (/\b(eco|ecomode|eco-mode|efficient|save-tokens|budget)\b/i.test(cleanPrompt)) {
+      activateState(directory, prompt, 'ecomode');
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('ecomode', prompt)
+      }));
+      return;
+    }
+
+    // Priority 7: Swarm - parse N from "swarm N agents"
+    const swarmMatch = cleanPrompt.match(/\bswarm\s+(\d+)\s+agents?\b/i);
+    if (swarmMatch || /\bcoordinated\s+agents\b/i.test(cleanPrompt)) {
+      const agentCount = swarmMatch ? swarmMatch[1] : '3'; // default 3
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('swarm', prompt, agentCount)
+      }));
+      return;
+    }
+
+    // Priority 8: Pipeline
+    if (/\b(pipeline)\b/i.test(cleanPrompt) || /\bchain\s+agents\b/i.test(cleanPrompt)) {
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('pipeline', prompt)
+      }));
+      return;
+    }
+
+    // Priority 9: Ralplan keyword (before plan to avoid false match)
+    if (/\b(ralplan)\b/i.test(cleanPrompt)) {
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('ralplan', prompt)
+      }));
+      return;
+    }
+
+    // Priority 10: Plan keywords
+    if (/\b(plan this|plan the)\b/i.test(cleanPrompt)) {
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('plan', prompt)
+      }));
+      return;
+    }
+
+    // Priority 11: TDD
+    if (/\b(tdd)\b/i.test(cleanPrompt) ||
+        /\btest\s+first\b/i.test(cleanPrompt) ||
+        /\bred\s+green\b/i.test(cleanPrompt)) {
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('tdd', prompt)
+      }));
+      return;
+    }
+
+    // Priority 12: Research
+    // "research" alone OR "analyze data" OR "statistics" trigger research skill
+    if (/\b(research)\b/i.test(cleanPrompt) ||
+        /\banalyze\s+data\b/i.test(cleanPrompt) ||
+        /\bstatistics\b/i.test(cleanPrompt)) {
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('research', prompt)
+      }));
       return;
     }
 
-    // Check for ultrathink/think keywords
-    if (/\b(ultrathink|think)\b/.test(cleanPrompt)) {
+    // Priority 13: Ultrathink/think keywords (keep inline message)
+    if (/\b(ultrathink|think hard|think deeply)\b/i.test(cleanPrompt)) {
       console.log(JSON.stringify({ continue: true, message: ULTRATHINK_MESSAGE }));
       return;
     }
 
-    // Check for search keywords
-    if (/\b(search|find|locate|lookup|explore|discover|scan|grep|query|browse|detect|trace|seek|track|pinpoint|hunt)\b|where\s+is|show\s+me|list\s+all/.test(cleanPrompt)) {
-      console.log(JSON.stringify({ continue: true, message: SEARCH_MESSAGE }));
+    // Priority 14: Deepsearch (RESTRICTED patterns)
+    if (/\b(deepsearch)\b/i.test(cleanPrompt) ||
+        /\bsearch\s+(the\s+)?(codebase|code|files?|project)\b/i.test(cleanPrompt) ||
+        /\bfind\s+(in\s+)?(codebase|code|all\s+files?)\b/i.test(cleanPrompt)) {
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('deepsearch', prompt)
+      }));
       return;
     }
 
-    // Check for analyze keywords
-    if (/\b(analyze|analyse|investigate|examine|research|study|deep.?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to/.test(cleanPrompt)) {
-      console.log(JSON.stringify({ continue: true, message: ANALYZE_MESSAGE }));
+    // Priority 15: Analyze (RESTRICTED patterns)
+    if (/\b(deep\s*analyze)\b/i.test(cleanPrompt) ||
+        /\binvestigate\s+(the|this|why)\b/i.test(cleanPrompt) ||
+        /\bdebug\s+(the|this|why)\b/i.test(cleanPrompt)) {
+      console.log(JSON.stringify({
+        continue: true,
+        message: createSkillInvocation('analyze', prompt)
+      }));
       return;
     }
 

package/scripts/post-tool-verifier.mjs

@@ -15,6 +15,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const distDir = join(__dirname, '..', 'dist', 'hooks', 'notepad');
+const clearSuggestionsDistDir = join(__dirname, '..', 'dist', 'hooks', 'clear-suggestions');
 
 // Try to import notepad functions (may fail if not built)
 let setPriorityContext = null;
@@ -27,6 +28,15 @@ try {
   // Notepad module not available - remember tags will be silently ignored
 }
 
+// Try to import clear suggestions functions (may fail if not built)
+let checkClearSuggestion = null;
+try {
+  const clearSuggestionsModule = await import(join(clearSuggestionsDistDir, 'index.js'));
+  checkClearSuggestion = clearSuggestionsModule.checkClearSuggestion;
+} catch {
+  // Clear suggestions module not available - will be silently skipped
+}
+
 // State file for session tracking
 const STATE_FILE = join(homedir(), '.claude', '.session-stats.json');
 
@@ -262,9 +272,37 @@ async function main() {
     // Generate contextual message
     const message = generateMessage(toolName, toolOutput, sessionId, toolCount);
 
+    // Check for clear suggestions (complements /compact suggestions)
+    let clearSuggestionMessage = null;
+    if (checkClearSuggestion) {
+      try {
+        const stats = loadStats();
+        const session = stats.sessions[sessionId];
+        // Estimate context usage from total tool calls (rough heuristic)
+        const estimatedContextRatio = session ? Math.min(session.total_calls / 200, 1.0) : 0;
+
+        const clearResult = checkClearSuggestion({
+          sessionId,
+          directory,
+          toolName,
+          toolOutput,
+          contextUsageRatio: estimatedContextRatio,
+        });
+
+        if (clearResult.shouldSuggest && clearResult.message) {
+          clearSuggestionMessage = clearResult.message;
+        }
+      } catch {
+        // Clear suggestion check failed - continue without it
+      }
+    }
+
     // Build response
     const response = { continue: true };
-    if (message) {
+    // Prefer clear suggestion over contextual message (more impactful)
+    if (clearSuggestionMessage) {
+      response.message = clearSuggestionMessage;
+    } else if (message) {
       response.message = message;
     }