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>

.codex/skills/team-coordinate/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: team-coordinate
 description: Universal team coordination skill with dynamic role generation. Uses team-worker agent architecture with role-spec files. Only coordinator is built-in -- all worker roles are generated at runtime as role-specs and spawned via team-worker agent. Beat/cadence model for orchestration. Triggers on "Team Coordinate ".
-allowed-tools: spawn_agent(*), wait_agent(*), send_input(*), close_agent(*), report_agent_job_result(*), request_user_input(*), Read(*), Write(*), Edit(*), Bash(*), Glob(*), Grep(*)
+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(*)
 ---
 
 # Team Coordinate
@@ -40,7 +40,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 |
@@ -136,6 +137,8 @@ When coordinator spawns workers, use `team-worker` agent with role-spec path:
 ```
 spawn_agent({
   agent_type: "team_worker",
+  task_name: "<task-id>",
+  fork_context: false,
   items: [
     { type: "text", text: `## Role Assignment
 role: <role>
@@ -159,7 +162,7 @@ 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: <name> })` each worker.
 
 **Inner Loop roles** (role has 2+ serial same-prefix tasks): Set `inner_loop: true`. The team-worker agent handles the loop internally.
 
@@ -167,6 +170,71 @@ After spawning, use `wait_agent({ ids: [...], timeout_ms: 900000 })` to collect
 
 ---
 
+
+### Model Selection Guide
+
+Roles are **dynamically generated** at runtime. Select model/reasoning_effort based on the generated role's `responsibility_type`:
+
+| responsibility_type | model | reasoning_effort | Rationale |
+|---------------------|-------|-------------------|-----------|
+| exploration | (default) | medium | Read-heavy, less reasoning needed |
+| analysis | (default) | high | Deep analysis requires full reasoning |
+| implementation | (default) | high | Code generation needs precision |
+| synthesis | (default) | medium | Aggregation over generation |
+| review | (default) | high | Quality assessment needs deep reasoning |
+
+Map each generated role's `responsibility_type` (from `team-session.json#roles`) to the table above.
+
+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: [...]
+})
+```
+
+## v4 Agent Coordination
+
+### Message Semantics
+
+| Intent | API | Example |
+|--------|-----|---------|
+| Queue supplementary info (don't interrupt) | `send_message` | Send upstream task findings to a running downstream worker |
+| Not used in this skill | `assign_task` | No resident agents -- all workers are one-shot |
+| Check running agents | `list_agents` | Verify agent health during resume |
+
+**Note**: Since roles are dynamically generated, the coordinator must resolve task prefixes and role names from `team-session.json#roles` at runtime. There are no hardcoded role-specific examples.
+
+### fork_context Strategy
+
+`fork_context: false` is the default. Consider `fork_context: true` only when:
+- Runtime analysis reveals the task requires deep familiarity with the full conversation context
+- The dynamically-generated role-spec indicates the worker needs project-wide understanding
+- The coordinator has already accumulated significant context about the codebase
+
+This decision should be made per-task during Phase 4 based on the role's `responsibility_type`.
+
+### Agent Health Check
+
+Use `list_agents({})` in handleResume and handleComplete:
+
+```
+// Reconcile session state with actual running agents
+const running = list_agents({})
+// Compare with team-session.json active_workers
+// 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: "<TASK-ID>", items: [...] })` -- queue upstream context without interrupting
+- `close_agent({ target: "<TASK-ID>" })` -- cleanup by name
+
 ## Completion Action
 
 When pipeline completes (all tasks done), coordinator presents an interactive choice:

.codex/skills/team-coordinate/roles/coordinator/commands/monitor.md

@@ -68,7 +68,7 @@ Receive result from wait_agent for [<role>]
   |   +- YES -> Update session state, do NOT remove from active_workers -> STOP
   +- Task status = completed?
   |   +- YES -> remove from active_workers -> update session
-  |   |   +- Close agent: close_agent({ id: <agentId> })
+  |   |   +- Close agent: close_agent({ target: <agentId> })
   |   |   +- -> handleSpawnNext
   |   +- NO -> progress message, do not advance -> STOP
   +- No matching worker found
@@ -114,6 +114,16 @@ Then STOP.
 
 ### Handler: 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
+```
+
 Check active worker completion, process results, advance pipeline.
 
 ```
@@ -155,11 +165,27 @@ Ready tasks found?
       Update session file -> output summary -> STOP
 ```
 
+**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 upstream task results to running downstream workers
+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.
+
 **Spawn worker call** (one per ready task):
 
 ```
 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: <session-folder>/role-specs/<role>.md
@@ -171,16 +197,30 @@ inner_loop: <true|false>
 
 Read role_spec file to load Phase 2-4 domain instructions.` }]
 })
-// Collect results:
-const result = wait_agent({ ids: [agentId], timeout_ms: 900000 })
-// Process result, update tasks.json
-close_agent({ id: agentId })
+// Collect results — use task_name for stable targeting (v4):
+const result = wait_agent({ targets: [taskId], timeout_ms: 900000 })
+if (result.timed_out) {
+  state.tasks[taskId].status = 'timed_out'
+  close_agent({ target: taskId })
+  // Report timeout, STOP — let user decide retry
+} else {
+  // Process result, update tasks.json
+  close_agent({ target: taskId })  // Use task_name, not agentId
+}
 ```
 
 ---
 
 ### Handler: 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 complete. Execute completion action based on session configuration.
 
 ```

.codex/skills/team-coordinate/roles/coordinator/role.md

@@ -31,7 +31,7 @@ OK: Write(".workflow/.team/TC-xxx/tasks.json", ...)   — task management
 OK: Read("roles/coordinator/commands/analyze-task.md") — own instructions
 OK: Read("specs/role-spec-template.md")               — generating role-specs
 OK: spawn_agent({ agent_type: "team_worker", ... })   — delegation
-OK: wait_agent({ ids: [...] })                        — monitoring
+OK: wait_agent({ targets: [...], timeout_ms: 900000 })     — monitoring
 ```
 
 **Self-check gate**: After Phase 1 analysis, before ANY other action, ask yourself:
@@ -57,6 +57,8 @@ OK: wait_agent({ ids: [...] })                        — monitoring
 - Handle consensus_blocked HIGH verdicts (create revision tasks or pause)
 - Detect fast-advance orphans on resume/check and reset to pending
 - Execute completion action when pipeline finishes
+- 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
 - **Read source code or perform codebase exploration** (delegate to worker roles)
@@ -124,6 +126,7 @@ Phase 1 needs task analysis
 | tasks.json | File | Task lifecycle (create/read/update) |
 | team_msg | System | Message bus operations |
 | request_user_input | System | User interaction |
+| list_agents | System | Runtime agent discovery and health check |
 
 ---
 
@@ -373,6 +376,16 @@ Delegate to `@commands/dispatch.md` which creates the full task chain:
 
 ---
 
+## 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 |