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-uidesign/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: team-uidesign
 description: Unified team skill for UI design team. Research -> design tokens -> audit -> implementation. Uses team-worker agent architecture with roles/ for domain logic. Coordinator orchestrates dual-track pipeline with GC loops and sync points. Triggers on "team ui design", "ui design team".
-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__read_file(*), mcp__ccw-tools__write_file(*), mcp__ccw-tools__edit_file(*), 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__read_file(*), mcp__ccw-tools__write_file(*), mcp__ccw-tools__edit_file(*), mcp__ccw-tools__team_msg(*)
 ---
 
 # Team UI Design
@@ -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,7 +111,38 @@ 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
+
+UI design is a creative pipeline where research findings inform design decisions. Researcher needs thorough analysis, designer needs creative reasoning.
+
+| Role | reasoning_effort | Rationale |
+|------|-------------------|-----------|
+| researcher | high | Deep analysis of existing design systems and patterns |
+| designer | high | Creative design token/component spec generation |
+| reviewer | high | Design audit must catch consistency and accessibility issues |
+| implementer | medium | Implementation follows defined design specs |
+
+### Research-to-Design Context Flow
+
+Researcher findings must reach designer via coordinator's upstream context:
+```
+// After RESEARCH-001 completes, coordinator sends findings to designer
+spawn_agent({
+  agent_type: "team_worker",
+  task_name: "DESIGN-001",
+  fork_context: false,
+  items: [
+    ...,
+    { type: "text", text: `## Upstream Context
+Research findings: <session>/research/design-intelligence.json
+Component inventory: <session>/research/component-inventory.json
+Accessibility audit: <session>/research/accessibility-audit.json` }
+  ]
+})
+```
 
 ## User Commands
 
@@ -145,6 +179,34 @@ After spawning, use `wait_agent({ ids: [...], timeout_ms: 900000 })` to collect
 └── wisdom/                    # Cross-task knowledge
 ```
 
+## v4 Agent Coordination
+
+### Message Semantics
+
+| Intent | API | Example |
+|--------|-----|---------|
+| Queue supplementary info (don't interrupt) | `send_message` | Send research findings to running designer |
+| Assign build from reviewed specs | `assign_task` | Assign BUILD task after audit passes |
+| Check running agents | `list_agents` | Verify agent health during resume |
+
+### Agent Health Check
+
+Use `list_agents({})` in handleResume and handleComplete:
+
+```
+// Reconcile session state with actual running agents
+const running = list_agents({})
+// Compare with meta.json active tasks
+// 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: "DESIGN-001", items: [...] })` -- send additional research findings to designer
+- `assign_task({ target: "BUILD-001", items: [...] })` -- assign implementation from reviewed design specs
+- `close_agent({ target: "AUDIT-001" })` -- cleanup after design audit
+
 ## Error Handling
 
 | Scenario | Resolution |

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

@@ -99,6 +99,16 @@ Output status -- do NOT advance pipeline.
 
 ## 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 tasks.json for inconsistencies:
    - Tasks stuck in "in_progress" -> reset to "pending"
    - Tasks with completed deps but still "pending" -> include in spawn list
@@ -124,6 +134,7 @@ state.tasks[taskId].status = 'in_progress'
 // 2) Spawn worker
 const agentId = spawn_agent({
   agent_type: "team_worker",
+  task_name: taskId,  // e.g., "DESIGN-001" — enables named targeting
   items: [
     { type: "text", text: `## Role Assignment
 role: ${role}
@@ -141,12 +152,18 @@ Execute built-in Phase 1 (task discovery) -> role Phase 2-4 -> built-in Phase 5
 // 3) Track agent
 state.active_agents[taskId] = { agentId, role, started_at: now }
 
-// 4) Wait for completion
-wait_agent({ ids: [agentId] })
-
-// 5) Collect results and update tasks.json
-state.tasks[taskId].status = 'completed'
-delete state.active_agents[taskId]
+// 4) Wait for completion — use task_name for stable targeting (v4)
+const waitResult = wait_agent({ targets: [taskId], timeout_ms: 900000 })
+if (waitResult.timed_out) {
+  state.tasks[taskId].status = 'timed_out'
+  close_agent({ target: taskId })
+  delete state.active_agents[taskId]
+} else {
+  // 5) Collect results and update tasks.json
+  state.tasks[taskId].status = 'completed'
+  close_agent({ target: taskId })  // Use task_name, not agentId
+  delete state.active_agents[taskId]
+}
 ```
 
 **Parallel spawn rules by mode**:
@@ -159,10 +176,33 @@ delete state.active_agents[taskId]
 | full-system | After Sync Point 1 | Spawn DESIGN-002 + BUILD-001 in parallel, wait_agent for both |
 | full-system | After BUILD-002 | Spawn AUDIT-003 |
 
+**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 design results to running implementer
+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.
+
 5. Update tasks.json, 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**:

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

@@ -6,7 +6,7 @@ UI Design Team coordinator. Orchestrate pipeline: analyze -> dispatch -> spawn -
 
 **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):
@@ -34,6 +34,8 @@ WRONG: Edit/Write on project source files            — worker work
 - Handle Generator-Critic loops with max 2 iterations
 - Maintain session state persistence (tasks.json)
 - **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 (researching, designing, auditing, building) -- workers handle this
@@ -187,6 +189,16 @@ Delegate to `@commands/monitor.md#handleSpawnNext`:
    })
    ```
 
+## 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 |