refactor: deep Codex v4 API conversion for all 20 team skills

Upgrade all team-* skills from mechanical v3→v4 API renames to deep v4 tool integration with skill-adaptive patterns: - list_agents: health checks in handleResume, cleanup verification in handleComplete, added to allowed-tools and coordinator toolbox - Named targeting: task_name uses task-id (e.g. EXPLORE-001) instead of generic <role>-worker, enabling send_message/assign_task by name - Message semantics: send_message for supplementary cross-agent context vs assign_task for triggering work, with skill-specific examples - Model selection: per-role reasoning_effort guidance matching each skill's actual roles (not generic boilerplate) - timeout_ms: added to all wait_agent calls, timed_out handling in all 18 monitor.md files - Skill-adaptive v4 sections: ultra-analyze N-parallel coordination, lifecycle-v4 supervisor assign_task/send_message distinction, brainstorm ideator parallel patterns, iterdev generator-critic loops, frontend-debug iterative debug assign_task, perf-opt benchmark context sharing, executor lightweight trimmed v4, etc. 60 files changed across 20 team skills (SKILL.md, monitor.md, role.md) Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-29 20:11:04 +08:00 · 2026-03-27 22:25:32 +08:00
parent 3d39ac6ac8
commit 88ea7fc6d7
60 changed files with 2318 additions and 215 deletions
--- a/.codex/skills/team-issue/SKILL.md
+++ b/.codex/skills/team-issue/SKILL.md
@@ -1,7 +1,7 @@
 ---
 name: team-issue
 description: Unified team skill for issue resolution. Uses team-worker agent architecture with role directories for domain logic. Coordinator orchestrates pipeline, workers are team-worker agents. Triggers on "team issue".
-allowed-tools: spawn_agent(*), wait_agent(*), send_input(*), close_agent(*), report_agent_job_result(*), request_user_input(*), Read(*), Write(*), Edit(*), Bash(*), Glob(*), Grep(*), mcp__ace-tool__search_context(*), mcp__ccw-tools__team_msg(*)
+allowed-tools: spawn_agent(*), wait_agent(*), send_message(*), assign_task(*), close_agent(*), list_agents(*), report_agent_job_result(*), request_user_input(*), Read(*), Write(*), Edit(*), Bash(*), Glob(*), Grep(*), mcp__ace-tool__search_context(*), mcp__ccw-tools__team_msg(*)
 ---

 # Team Issue Resolution
@@ -54,7 +54,8 @@ Before calling ANY tool, apply this check:

 | Tool Call | Verdict | Reason |
 |-----------|---------|--------|
-| `spawn_agent`, `wait_agent`, `close_agent`, `send_input` | ALLOWED | Orchestration |
+| `spawn_agent`, `wait_agent`, `close_agent`, `send_message`, `assign_task` | ALLOWED | Orchestration |
+| `list_agents` | ALLOWED | Agent health check |
 | `request_user_input` | ALLOWED | User interaction |
 | `mcp__ccw-tools__team_msg` | ALLOWED | Message bus |
 | `Read/Write` on `.workflow/.team/` files | ALLOWED | Session state |
@@ -85,6 +86,8 @@ Coordinator spawns workers using this template:
 ```
 spawn_agent({
  agent_type: "team_worker",
+  task_name: "<task-id>",
+  fork_context: false,
  items: [
    { type: "text", text: `## Role Assignment
 role: <role>
@@ -108,13 +111,15 @@ pipeline_phase: <pipeline-phase>` },
 })
 ```

-After spawning, use `wait_agent({ ids: [...], timeout_ms: 900000 })` to collect results, then `close_agent({ id })` each worker.
+After spawning, use `wait_agent({ targets: [...], timeout_ms: 900000 })` to collect results, then `close_agent({ target })` each worker.

 **Parallel spawn** (Batch mode, N explorer or M implementer instances):

 ```
 spawn_agent({
  agent_type: "team_worker",
+  task_name: "<task-id>",
+  fork_context: false,
  items: [
    { type: "text", text: `## Role Assignment
 role: <role>
@@ -139,7 +144,30 @@ pipeline_phase: <pipeline-phase>` },
 })
 ```

-After spawning, use `wait_agent({ ids: [...], timeout_ms: 900000 })` to collect results, then `close_agent({ id })` each worker.
+After spawning, use `wait_agent({ targets: [...], timeout_ms: 900000 })` to collect results, then `close_agent({ target })` each worker.
+
+
+### Model Selection Guide
+
+| Role | model | reasoning_effort | Rationale |
+|------|-------|-------------------|-----------|
+| Explorer (EXPLORE-*) | (default) | medium | Context gathering, file reading, less reasoning |
+| Planner (SOLVE-*) | (default) | high | Solution design requires deep analysis |
+| Reviewer (AUDIT-*) | (default) | high | Code review and plan validation need full reasoning |
+| Integrator (MARSHAL-*) | (default) | medium | Queue ordering and dependency resolution |
+| Implementer (BUILD-*) | (default) | high | Code generation needs precision |
+
+Override model/reasoning_effort in spawn_agent when cost optimization is needed:
+```
+spawn_agent({
+  agent_type: "team_worker",
+  task_name: "<task-id>",
+  fork_context: false,
+  model: "<model-override>",
+  reasoning_effort: "<effort-level>",
+  items: [...]
+})
+```

 ## User Commands

@@ -176,6 +204,57 @@ After spawning, use `wait_agent({ ids: [...], timeout_ms: 900000 })` to collect

 - [specs/pipelines.md](specs/pipelines.md) — Pipeline definitions and task registry

+## v4 Agent Coordination
+
+### Message Semantics
+
+| Intent | API | Example |
+|--------|-----|---------|
+| Send exploration context to running planner | `send_message` | Queue EXPLORE-* findings to SOLVE-* worker |
+| Not used in this skill | `assign_task` | No resident agents -- all workers are one-shot |
+| Check running agents | `list_agents` | Verify parallel explorer/implementer health |
+
+### Pipeline Pattern
+
+Pipeline with context passing: explore -> plan -> review (optional) -> marshal -> implement. In **Batch mode**, N explorers and M implementers run in parallel:
+
+```
+// Batch mode: spawn N explorers in parallel (max 5)
+const explorerNames = ["EXPLORE-001", "EXPLORE-002", ..., "EXPLORE-00N"]
+for (const name of explorerNames) {
+  spawn_agent({ agent_type: "team_worker", task_name: name, ... })
+}
+wait_agent({ targets: explorerNames, timeout_ms: 900000 })
+
+// After MARSHAL completes: spawn M implementers in parallel (max 3)
+const buildNames = ["BUILD-001", "BUILD-002", ..., "BUILD-00M"]
+for (const name of buildNames) {
+  spawn_agent({ agent_type: "team_worker", task_name: name, ... })
+}
+wait_agent({ targets: buildNames, timeout_ms: 900000 })
+```
+
+### Review-Fix Cycle
+
+Reviewer (AUDIT-*) may reject plans, triggering fix cycles (max 2). Dynamic SOLVE-fix and AUDIT re-review tasks are created in tasks.json.
+
+### Agent Health Check
+
+Use `list_agents({})` in handleResume and handleComplete:
+
+```
+// Reconcile session state with actual running agents
+const running = list_agents({})
+// Compare with tasks.json active_agents
+// Reset orphaned tasks (in_progress but agent gone) to pending
+```
+
+### Named Agent Targeting
+
+Workers are spawned with `task_name: "<task-id>"` enabling direct addressing:
+- `send_message({ target: "SOLVE-001", items: [...] })` -- queue exploration context to running planner
+- `close_agent({ target: "BUILD-001" })` -- cleanup by name after completion
+
 ## Error Handling

 | Scenario | Resolution |
--- a/.codex/skills/team-issue/roles/coordinator/commands/monitor.md
+++ b/.codex/skills/team-issue/roles/coordinator/commands/monitor.md
@@ -61,7 +61,7 @@ Worker completed. Process and advance.
   - Create BUILD-001..M tasks dynamically (add to tasks.json per dispatch.md Batch Pipeline BUILD section)
   - Proceed to handleSpawnNext

-6. Close completed agent: `close_agent({ id: <agentId> })`
+6. Close completed agent: `close_agent({ target: <agentId> })`
 7. Proceed to handleSpawnNext

 ## handleCheck
@@ -79,6 +79,16 @@ Read-only status report, then STOP.

 ## handleResume

+**Agent Health Check** (v4):
+```
+// Verify actual running agents match session state
+const runningAgents = list_agents({})
+// For each active_agent in tasks.json:
+//   - If agent NOT in runningAgents -> agent crashed
+//   - Reset that task to pending, remove from active_agents
+// This prevents stale agent references from blocking the pipeline
+```
+
 1. Audit task list: Tasks stuck in "in_progress" -> reset to "pending"
 2. Proceed to handleSpawnNext

@@ -96,6 +106,7 @@ Find ready tasks, spawn workers, STOP.
      ```
      const agentId = spawn_agent({
        agent_type: "team_worker",
+        task_name: taskId,  // e.g., "EXPLORE-001" — enables named targeting
        items: [{ type: "text", text: `## Role Assignment
      role: <role>
      role_spec: ~  or <project>/.codex/skills/team-issue/roles/<role>/role.md
@@ -109,10 +120,10 @@ Find ready tasks, spawn workers, STOP.
      Execute built-in Phase 1 (task discovery) -> role Phase 2-4 -> built-in Phase 5 (report).` }]
      })
      ```
-   d. Collect results: `wait_agent({ ids: [agentId], timeout_ms: 900000 })`
+   d. Collect results: `wait_agent({ targets: [taskId], timeout_ms: 900000 })`
   e. Read discoveries from output files
   f. Update tasks.json with results
-   g. Close agent: `close_agent({ id: agentId })`
+   g. Close agent: `close_agent({ target: taskId })`  // Use task_name, not agentId

 5. Parallel spawn rules:

@@ -130,6 +141,7 @@ const agentIds = []
 for (const task of readyTasks) {
  agentIds.push(spawn_agent({
    agent_type: "team_worker",
+    task_name: task.id,  // e.g., "EXPLORE-001" — enables named targeting
    items: [{ type: "text", text: `## Role Assignment
 role: <role>
 role_spec: ~  or <project>/.codex/skills/team-issue/roles/<role>/role.md
@@ -144,15 +156,44 @@ Read role_spec file to load Phase 2-4 domain instructions.
 Execute built-in Phase 1 (task discovery, owner=<role>-<N>) -> role Phase 2-4 -> built-in Phase 5 (report).` }]
  }))
 }
-const results = wait_agent({ ids: agentIds, timeout_ms: 900000 })
-// Process results, close agents
-for (const id of agentIds) { close_agent({ id }) }
+// Use task_name for stable targeting (v4)
+const taskNames = readyTasks.map(t => t.id)
+const results = wait_agent({ targets: taskNames, timeout_ms: 900000 })
+if (results.timed_out) {
+  for (const taskId of taskNames) { state.tasks[taskId].status = 'timed_out'; close_agent({ target: taskId }) }
+} else {
+  // Process results, close agents
+  for (const taskId of taskNames) { close_agent({ target: taskId }) }
+}
 ```

+**Cross-Agent Supplementary Context** (v4):
+
+When spawning workers in a later pipeline phase, send upstream results as supplementary context to already-running workers:
+
+```
+// Example: Send exploration results to running planner
+send_message({
+  target: "<running-agent-task-name>",
+  items: [{ type: "text", text: `## Supplementary Context\n${upstreamFindings}` }]
+})
+// Note: send_message queues info without interrupting the agent's current work
+```
+
+Use `send_message` (not `assign_task`) for supplementary info that enriches but doesn't redirect the agent's current task.
+
 6. Update session, output summary, STOP

 ## handleComplete

+**Cleanup Verification** (v4):
+```
+// Verify all agents are properly closed
+const remaining = list_agents({})
+// If any team agents still running -> close_agent each
+// Ensures clean session shutdown
+```
+
 Pipeline done. Generate report and completion action.

 Completion check by mode:
--- a/.codex/skills/team-issue/roles/coordinator/role.md
+++ b/.codex/skills/team-issue/roles/coordinator/role.md
@@ -10,7 +10,7 @@ Orchestrate the issue resolution pipeline: clarify requirements -> create team -

 **You are a dispatcher, not a doer.** Your ONLY outputs are:
 - Session state files (`.workflow/.team/` directory)
- `spawn_agent` / `wait_agent` / `close_agent` / `send_input` calls
+- `spawn_agent` / `wait_agent` / `close_agent` / `send_message` / `assign_task` calls
 - Status reports to the user / `request_user_input` prompts

 **FORBIDDEN** (even if the task seems trivial):
@@ -38,6 +38,8 @@ WRONG: Edit/Write on project source files            — worker work
 - Handle review-fix cycles with max 2 iterations
 - Execute completion action in Phase 5
 - **Always proceed through full Phase 1-5 workflow, never skip to direct execution**
+- Use `send_message` for supplementary context (non-interrupting) and `assign_task` for triggering new work
+- Use `list_agents` for session resume health checks and cleanup verification

 ### MUST NOT
 - Implement domain logic (exploring, planning, reviewing, implementing) -- workers handle this
@@ -183,6 +185,16 @@ Delegate to @commands/monitor.md#handleSpawnNext:
 | Keep Active | Update session status="paused" -> output: "Resume with: Skill(skill='team-issue', args='resume')" |
 | New Batch | Return to Phase 1 |

+## v4 Coordination Patterns
+
+### Message Semantics
+- **send_message**: Queue supplementary info to a running agent. Does NOT interrupt current processing. Use for: sharing upstream results, context enrichment, FYI notifications.
+- **assign_task**: Assign new work and trigger processing. Use for: waking idle agents, redirecting work, requesting new output.
+
+### Agent Lifecycle Management
+- **list_agents({})**: Returns all running agents. Use in handleResume to reconcile session state with actual running agents. Use in handleComplete to verify clean shutdown.
+- **Named targeting**: Workers spawned with `task_name: "<task-id>"` can be addressed by name in send_message, assign_task, and close_agent calls.
+
 ## Error Handling

 | Error | Resolution |