/plugin marketplace add https://github.com/Yeachan-Heo/oh-my-claudecode
/plugin install oh-my-claudecode

/setup

npm i -g oh-my-claude-sisyphus@latest

omc setup

omc setup --plugin-dir-mode
# or
export OMC_PLUGIN_ROOT=/path/to/plugins
omc setup

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

team-plan → team-prd → team-exec → team-verify → team-fix (loop)

# Fix TypeScript errors with 3 executor agents
/team 3:executor "fix all TypeScript errors"

# Review security with 2 reviewer agents
/team 2:reviewer "audit authentication flow"

# General development task
/team 4:developer "implement user profile feature"

# 2 Codex CLI workers for code review
omc team 2:codex "review auth module for security issues"

# 2 Gemini CLI workers for UI design
omc team 2:gemini "redesign UI components for accessibility"

# 1 Claude CLI worker
omc team 1:claude "implement the payment flow"

# Check worker status
omc team status auth-review

# Shutdown workers
omc team shutdown auth-review

/deep-interview "I want to build a task management app"

/deep-interview --autoresearch "build an e-commerce platform"

# In-session
/autopilot "build a REST API for managing tasks"

# Natural language shortcut
autopilot: build a REST API for managing tasks

/ccg Review this PR — architecture (Codex) and UI components (Gemini)

# Ask Codex specifically
/ask codex "review this authentication implementation"

# Ask Gemini specifically
/ask gemini "suggest improvements to this component design"

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1",
    "OMC_PLUGIN_ROOT": "/path/to/plugins",
    "ANTHROPIC_API_KEY": "${ANTHROPIC_API_KEY}",
    "OPENAI_API_KEY": "${OPENAI_API_KEY}",
    "GEMINI_API_KEY": "${GEMINI_API_KEY}"
  }
}

// agents/custom-reviewer.ts
export interface AgentConfig {
  role: string;
  capabilities: string[];
  model: string;
}

export const customReviewer: AgentConfig = {
  role: "security-reviewer",
  capabilities: [
    "security-audit",
    "vulnerability-detection",
    "code-review"
  ],
  model: "claude-sonnet-4"
};

// workflows/deployment-pipeline.ts
import { TeamOrchestrator } from 'oh-my-claude-sisyphus';

async function runDeploymentPipeline() {
  const orchestrator = new TeamOrchestrator({
    agents: 3,
    role: 'executor',
    task: 'run full deployment pipeline'
  });

  await orchestrator.execute();
  
  const results = await orchestrator.verify();
  if (!results.allPassed) {
    await orchestrator.fix(results.failures);
  }
}

// skills/custom-workflow.ts
export const customWorkflowSkill = {
  name: 'custom-workflow',
  description: 'Custom development workflow',
  
  async execute(context: SkillContext) {
    // 1. Requirements gathering
    await context.runSkill('/deep-interview', {
      prompt: context.userInput
    });
    
    // 2. Team execution
    await context.runSkill('/team', {
      agents: 3,
      role: 'executor',
      task: context.clarifiedRequirements
    });
    
    // 3. Verification
    await context.runSkill('/verify', {
      criteria: context.acceptanceCriteria
    });
  }
};

# 1. Clarify requirements
/deep-interview "add user authentication"

# 2. Execute with team
/team 4:developer "implement OAuth2 authentication based on requirements doc"

# 3. Review with specialized agents
/team 2:reviewer "security audit authentication implementation"

# Use CLI workers for multi-model review
omc team 1:codex "review code architecture and design patterns"
omc team 1:gemini "review user experience and component structure"

# Or use tri-model advisory
/ccg Complete code review covering architecture, security, and UX

# Deep interview for strategy
/deep-interview "refactor monolith to microservices"

# Parallel execution with team
/team 5:executor "implement microservices architecture per plan"

# Continuous verification
/team 2:validator "verify service boundaries and API contracts"

# Start with autoresearch
/deep-interview --autoresearch "build real-time collaborative editor"

# Execute with findings
/autopilot "implement collaborative editor using CRDTs based on research"

# Basic setup
omc setup

# Setup with plugin directory mode
omc setup --plugin-dir-mode

# Force reinstall
omc setup --force

# Spawn team workers
omc team <N>:<role> "<task>"

# Worker status
omc team status <task-id>

# Shutdown workers
omc team shutdown <task-id>

# List all active teams
omc team list

# Run diagnostics
/omc-doctor

# Check plugin status
/plugin list

# Update marketplace plugin
/plugin marketplace update omc

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

# Clear plugin cache
/omc-doctor

# Reinstall plugin
/plugin marketplace update omc
/setup

export OMC_PLUGIN_ROOT=/path/to/plugins
omc setup --plugin-dir-mode

npm i -g oh-my-claude-sisyphus@latest

// Hybrid workflow: deep interview → team → autopilot cleanup
async function hybridWorkflow(task: string) {
  // Phase 1: Requirements
  const requirements = await runDeepInterview(task);
  
  // Phase 2: Core implementation with team
  await runTeam({
    agents: 4,
    role: 'executor',
    task: requirements.implementation
  });
  
  // Phase 3: Polish with autopilot
  await runAutopilot({
    task: 'refine and optimize implementation',
    context: requirements
  });
}

// Add custom provider to advisory workflow
export async function consultProviders(
  question: string,
  providers: string[]
) {
  const responses = await Promise.all(
    providers.map(p => askProvider(p, question))
  );
  
  return synthesizeResponses(responses);
}

// Usage
const feedback = await consultProviders(
  "Review this architecture",
  ["codex", "gemini", "claude"]
);

// Track long-running tasks across sessions
interface PersistentTask {
  id: string;
  status: 'planning' | 'executing' | 'verifying' | 'complete';
  checkpoint: any;
}

export async function resumeTask(taskId: string) {
  const task = await loadTask(taskId);
  
  switch (task.status) {
    case 'planning':
      await runTeamPlan(task);
      break;
    case 'executing':
      await runTeamExec(task);
      break;
    case 'verifying':
      await runTeamVerify(task);
      break;
  }
}