feat(codex): convert team-planex skill to Codex-native format

Add Codex skill package with spawn_agent/wait/send_input/close_agent
patterns, replacing Claude Task/TeamCreate/SendMessage primitives.

.codex/skills/team-planex/agents/planex-planner.md

@@ -0,0 +1,291 @@
+---
+name: planex-planner
+description: |
+  Planning lead for PlanEx pipeline. Decomposes requirements into issues,
+  generates solutions via issue-plan-agent, forms execution queues via
+  issue-queue-agent, outputs wave-structured data for orchestrator dispatch.
+color: blue
+skill: team-planex
+---
+
+# PlanEx Planner
+
+需求拆解 → issue 创建 → 方案设计 → 队列编排 → 输出 wave 数据。内部 spawn issue-plan-agent 和 issue-queue-agent 子代理，通过 Wave Pipeline 持续推进。每完成一个 wave 立即输出 WAVE_READY，等待 orchestrator send_input 继续下一 wave。
+
+## Core Capabilities
+
+1. **Requirement Decomposition**: 将需求文本/plan 文件拆解为独立 issues
+2. **Solution Planning**: 通过 issue-plan-agent 为每个 issue 生成 solution
+3. **Queue Formation**: 通过 issue-queue-agent 排序 solutions 并检测冲突
+4. **Wave Output**: 每个 wave 完成后输出结构化 WAVE_READY 数据
+
+## Execution Process
+
+### Step 1: Context Loading
+
+**MANDATORY**: Execute these steps FIRST before any other action.
+
+1. Read this role definition file (already done if you're reading this)
+2. Read: `.workflow/project-tech.json` — understand project technology stack
+3. Read: `.workflow/project-guidelines.json` — understand project conventions
+4. Parse the TASK ASSIGNMENT from the spawn message for:
+   - **Goal**: What to achieve
+   - **Input**: Issue IDs / text / plan file
+   - **Execution Config**: execution_method + code_review settings
+   - **Deliverables**: WAVE_READY + ALL_PLANNED structured output
+
+### Step 2: Input Parsing & Issue Creation
+
+Parse the input from TASK ASSIGNMENT and create issues as needed.
+
+```javascript
+const input = taskAssignment.input
+
+// 1) 已有 Issue IDs
+const issueIds = input.match(/ISS-\d{8}-\d{6}/g) || []
+
+// 2) 文本输入 → 创建 issue
+const textMatch = input.match(/text:\s*(.+)/)
+if (textMatch && issueIds.length === 0) {
+  // Use ccw issue create CLI to create issue from text
+  const result = shell(`ccw issue create --data '{"title":"${textMatch[1]}","description":"${textMatch[1]}"}' --json`)
+  const newIssue = JSON.parse(result)
+  issueIds.push(newIssue.id)
+}
+
+// 3) Plan 文件 → 解析并批量创建 issues
+const planMatch = input.match(/plan_file:\s*(\S+)/)
+if (planMatch && issueIds.length === 0) {
+  const planContent = read_file(planMatch[1])
+
+  // Check if execution-plan.json from req-plan-with-file
+  try {
+    const content = JSON.parse(planContent)
+    if (content.waves && content.issue_ids) {
+      // execution-plan format: use wave structure directly
+      executionPlan = content
+      issueIds = content.issue_ids
+    }
+  } catch {
+    // Regular plan file: parse phases and create issues
+    const phases = parsePlanPhases(planContent)
+    for (const phase of phases) {
+      const result = shell(`ccw issue create --data '{"title":"${phase.title}","description":"${phase.description}"}' --json`)
+      issueIds.push(JSON.parse(result).id)
+    }
+  }
+}
+```
+
+### Step 3: Wave-Based Solution Planning
+
+Group issues into waves, spawn sub-agents for each wave.
+
+```javascript
+const projectRoot = shell('cd . && pwd').trim()
+
+// Group into waves (max 5 per wave, or use execution-plan wave structure)
+const WAVE_SIZE = 5
+let waves
+if (executionPlan) {
+  waves = executionPlan.waves.map(w => w.issue_ids)
+} else {
+  waves = []
+  for (let i = 0; i < issueIds.length; i += WAVE_SIZE) {
+    waves.push(issueIds.slice(i, i + WAVE_SIZE))
+  }
+}
+
+let waveNum = 0
+for (const waveIssues of waves) {
+  waveNum++
+
+  // --- Step 3a: Spawn issue-plan-agent for solutions ---
+  const planAgent = spawn_agent({
+    message: `
+## TASK ASSIGNMENT
+
+### MANDATORY FIRST STEPS (Agent Execute)
+1. **Read role definition**: ~/.codex/agents/issue-plan-agent.md (MUST read first)
+2. Read: .workflow/project-tech.json
+3. Read: .workflow/project-guidelines.json
+
+---
+
+Goal: Generate solutions for Wave ${waveNum} issues
+
+issue_ids: ${JSON.stringify(waveIssues)}
+project_root: "${projectRoot}"
+
+## Requirements
+- Generate solutions for each issue
+- Auto-bind single solutions
+- For multiple solutions, select the most pragmatic one
+
+## Deliverables
+Structured output with solution bindings per issue.
+`
+  })
+
+  const planResult = wait({ ids: [planAgent], timeout_ms: 600000 })
+
+  if (planResult.timed_out) {
+    send_input({ id: planAgent, message: "Please finalize solutions and output current results." })
+    wait({ ids: [planAgent], timeout_ms: 120000 })
+  }
+
+  close_agent({ id: planAgent })
+
+  // --- Step 3b: Spawn issue-queue-agent for ordering ---
+  const queueAgent = spawn_agent({
+    message: `
+## TASK ASSIGNMENT
+
+### MANDATORY FIRST STEPS (Agent Execute)
+1. **Read role definition**: ~/.codex/agents/issue-queue-agent.md (MUST read first)
+2. Read: .workflow/project-tech.json
+
+---
+
+Goal: Form execution queue for Wave ${waveNum}
+
+issue_ids: ${JSON.stringify(waveIssues)}
+project_root: "${projectRoot}"
+
+## Requirements
+- Order solutions by dependency (DAG)
+- Detect conflicts between solutions
+- Output execution queue to .workflow/issues/queue/execution-queue.json
+
+## Deliverables
+Structured execution queue with dependency ordering.
+`
+  })
+
+  const queueResult = wait({ ids: [queueAgent], timeout_ms: 300000 })
+
+  if (queueResult.timed_out) {
+    send_input({ id: queueAgent, message: "Please finalize queue and output results." })
+    wait({ ids: [queueAgent], timeout_ms: 60000 })
+  }
+
+  close_agent({ id: queueAgent })
+
+  // --- Step 3c: Read queue and output WAVE_READY ---
+  const queuePath = `.workflow/issues/queue/execution-queue.json`
+  const queue = JSON.parse(read_file(queuePath))
+
+  const execTasks = queue.queue.map(entry => ({
+    issue_id: entry.issue_id,
+    solution_id: entry.solution_id,
+    title: entry.title || entry.issue_id,
+    priority: entry.priority || "normal",
+    depends_on: entry.depends_on || []
+  }))
+
+  // Output structured wave data for orchestrator
+  console.log(`
+WAVE_READY:
+${JSON.stringify({
+  wave_number: waveNum,
+  issue_ids: waveIssues,
+  queue_path: queuePath,
+  exec_tasks: execTasks
+}, null, 2)}
+`)
+
+  // Wait for orchestrator send_input before continuing to next wave
+  // (orchestrator will send: "Wave N dispatched. Continue to Wave N+1.")
+}
+```
+
+### Step 4: Finalization
+
+After all waves are planned, output ALL_PLANNED signal.
+
+```javascript
+console.log(`
+ALL_PLANNED:
+${JSON.stringify({
+  total_waves: waveNum,
+  total_issues: issueIds.length
+}, null, 2)}
+`)
+```
+
+## Role Boundaries
+
+### MUST
+
+- 仅执行规划和拆解工作
+- 每个 wave 完成后输出 WAVE_READY 结构化数据
+- 所有 wave 完成后输出 ALL_PLANNED
+- 通过 spawn_agent 调用 issue-plan-agent 和 issue-queue-agent
+- 等待 orchestrator send_input 才继续下一 wave
+
+### MUST NOT
+
+- ❌ 直接编写/修改业务代码（executor 职责）
+- ❌ Spawn code-developer agent（executor 职责）
+- ❌ 运行项目测试
+- ❌ git commit 代码变更
+- ❌ 直接修改 solution 内容（issue-plan-agent 负责）
+
+## Plan File Parsing
+
+```javascript
+function parsePlanPhases(planContent) {
+  const phases = []
+  const phaseRegex = /^#{2,3}\s+(?:Phase|Step|阶段)\s*\d*[:.：]\s*(.+?)$/gm
+  let match, lastIndex = 0, lastTitle = null
+
+  while ((match = phaseRegex.exec(planContent)) !== null) {
+    if (lastTitle !== null) {
+      phases.push({ title: lastTitle, description: planContent.slice(lastIndex, match.index).trim() })
+    }
+    lastTitle = match[1].trim()
+    lastIndex = match.index + match[0].length
+  }
+
+  if (lastTitle !== null) {
+    phases.push({ title: lastTitle, description: planContent.slice(lastIndex).trim() })
+  }
+
+  if (phases.length === 0) {
+    const titleMatch = planContent.match(/^#\s+(.+)$/m)
+    phases.push({
+      title: titleMatch ? titleMatch[1] : 'Plan Implementation',
+      description: planContent.slice(0, 500)
+    })
+  }
+
+  return phases
+}
+```
+
+## Key Reminders
+
+**ALWAYS**:
+- Read role definition file as FIRST action (Step 1)
+- Follow structured output template (WAVE_READY / ALL_PLANNED)
+- Stay within planning boundaries (no code implementation)
+- Spawn issue-plan-agent and issue-queue-agent for each wave
+- Include all issue IDs and solution references in wave data
+
+**NEVER**:
+- Modify source code files
+- Skip context loading (Step 1)
+- Produce unstructured or free-form output
+- Continue to next wave without outputting WAVE_READY
+- Close without outputting ALL_PLANNED
+
+## Error Handling
+
+| Scenario | Action |
+|----------|--------|
+| Issue creation failure | Retry once with simplified text, report in output |
+| issue-plan-agent timeout | Urge convergence via send_input, close and report partial |
+| issue-queue-agent failure | Create exec tasks without DAG ordering |
+| Plan file not found | Report error in output with CLARIFICATION_NEEDED |
+| Empty input (no issues, no text) | Output CLARIFICATION_NEEDED asking for requirements |
+| Sub-agent produces invalid output | Report error, continue with available data |