mirror of https://github.com/catlog22/Claude-Code-Workflow.git synced 2026-02-28 09:23:08 +08:00

Files

catlog22 a4fff6a591 feat: Add orchestrator template and roles for executor and planner

- Created a new orchestrator template for Codex skill design, detailing structure and execution phases.
- Introduced the executor role with responsibilities for task execution, including routing to backends and handling implementation.
- Added the planner role for requirement breakdown, issue creation, and task dispatching, ensuring a structured planning process.

2026-02-16 00:17:15 +08:00

5.3 KiB

Raw Blame History

Phase 1: Requirements Analysis

Analyze input source and extract Codex skill configuration.

Objective

Parse input source (text / Claude skill / requirements doc / Codex prompt)
Identify agents, phases, interaction patterns
Determine output mode (structured package vs single prompt)
Produce codexSkillConfig for downstream phases

Pre-Requisites

Read specification documents based on input source:

Always: Read specs/codex-agent-patterns.md for available patterns
Claude conversion: Also read specs/conversion-rules.md
Quality reference: Read specs/quality-standards.md for target criteria

Execution

Step 1.1: Input Source Detection

// Determine input type from workflowPreferences
const inputSource = workflowPreferences.inputSource

if (inputSource.includes("Claude Skill")) {
  // Read source Claude skill
  const sourceSkillPath = AskUserQuestion({
    questions: [{
      question: "Path to the Claude skill to convert?",
      header: "Skill Path",
      multiSelect: false,
      options: [
        { label: "Browse", description: "I'll provide the path" }
      ]
    }]
  })
  // Read SKILL.md + phases/*.md from source
  const skillContent = Read(sourceSkillPath)
  const phaseFiles = Glob(`${sourceSkillDir}/phases/*.md`)
} else if (inputSource.includes("Text Description")) {
  // Collect description via user interaction
} else if (inputSource.includes("Requirements Doc")) {
  // Read requirements file
} else if (inputSource.includes("Existing Codex")) {
  // Read existing Codex prompt for refactoring
}

Step 1.2: Skill Structure Extraction

For each input type, extract:

From Text Description:

const codexSkillConfig = {
  name: extractSkillName(userDescription),
  description: extractDescription(userDescription),
  outputMode: workflowPreferences.outputMode,
  agents: inferAgents(userDescription),
  phases: inferPhases(userDescription),
  parallelSplits: inferParallelism(userDescription),
  interactionModel: inferInteractionModel(userDescription),
  conversionSource: null
}

From Claude Skill (conversion):

// Parse Claude SKILL.md
const claudeConfig = {
  phases: extractPhases(skillContent),
  agents: extractTaskCalls(skillContent),       // Find Task() invocations
  dataFlow: extractDataFlow(skillContent),
  todoPattern: extractTodoPattern(skillContent),
  resumePatterns: findResumePatterns(skillContent)  // For send_input mapping
}

const codexSkillConfig = {
  name: claudeConfig.name,
  description: claudeConfig.description,
  outputMode: workflowPreferences.outputMode,
  agents: claudeConfig.agents.map(a => ({
    name: a.subagent_type,
    role_file: mapToCodexRolePath(a.subagent_type),
    responsibility: a.description,
    patterns: determinePatterns(a)
  })),
  phases: claudeConfig.phases.map(p => ({
    name: p.name,
    agents_involved: p.agentCalls.map(a => a.subagent_type),
    interaction_model: hasResume(p) ? "deep_interaction" : "standard"
  })),
  parallelSplits: detectParallelPatterns(claudeConfig),
  conversionSource: { type: "claude_skill", path: sourceSkillPath }
}

Step 1.3: Agent Inventory Check

Verify agent roles exist in ~/.codex/agents/:

const existingAgents = Glob("~/.codex/agents/*.md")
const requiredAgents = codexSkillConfig.agents.map(a => a.role_file)

const missingAgents = requiredAgents.filter(r =>
  !existingAgents.includes(r)
)

if (missingAgents.length > 0) {
  // Mark as "needs new agent role definition"
  codexSkillConfig.newAgentDefinitions = missingAgents
}

Step 1.4: Interaction Model Selection

Based on agent relationships, select interaction patterns:

Pattern	Condition	Result
Standard	Single agent, single task	`spawn → wait → close`
Parallel Fan-out	Multiple independent agents	`spawn[] → batch wait → close[]`
Deep Interaction	Multi-phase with context	`spawn → wait → send_input → wait → close`
Two-Phase	Needs clarification first	`spawn(clarify) → wait → send_input(answers) → wait → close`
Pipeline	Sequential agent chain	`spawn(A) → wait → spawn(B, with A result) → wait → close`

codexSkillConfig.phases.forEach(phase => {
  if (phase.agents_involved.length > 1) {
    phase.interaction_model = "parallel_fanout"
  } else if (phase.interaction_model === "deep_interaction") {
    // Already set from resume pattern detection
  } else {
    phase.interaction_model = "standard"
  }
})

Step 1.5: User Confirmation

Present extracted configuration for user review:

AskUserQuestion({
  questions: [{
    question: `Skill "${codexSkillConfig.name}" will have ${codexSkillConfig.agents.length} agent(s) and ${codexSkillConfig.phases.length} phase(s). ${codexSkillConfig.newAgentDefinitions?.length || 0} new agent definitions needed. Proceed?`,
    header: "Confirm",
    multiSelect: false,
    options: [
      { label: "Proceed", description: "Generate Codex skill package" },
      { label: "Adjust", description: "Modify configuration first" }
    ]
  }]
})

Output

Variable: codexSkillConfig — complete skill configuration
TodoWrite: Mark Phase 1 completed, Phase 2 in_progress

Next Phase

Return to orchestrator, then auto-continue to Phase 2: Orchestrator Design.

5.3 KiB Raw Blame History