claude-code-workflow 7.2.3 → 7.2.4

package/.codex/skills/team-perf-opt/SKILL.md

@@ -657,3 +657,41 @@ All agents (csv-wave and interactive) share a single `discoveries.ndjson` file f
 8. **Max 3 Fix Cycles**: Review-fix cycle capped at 3 iterations; escalate to user after
 9. **Cleanup Temp Files**: Remove wave-{N}.csv after results are merged
 10. **DO NOT STOP**: Continuous execution until all waves complete or all remaining tasks are skipped
+
+
+---
+
+## Coordinator Role Constraints (Main Agent)
+
+**CRITICAL**: The coordinator (main agent executing this skill) is responsible for **orchestration only**, NOT implementation.
+
+15. **Coordinator Does NOT Execute Code**: The main agent MUST NOT write, modify, or implement any code directly. All implementation work is delegated to spawned team agents. The coordinator only:
+    - Spawns agents with task assignments
+    - Waits for agent callbacks
+    - Merges results and coordinates workflow
+    - Manages workflow transitions between phases
+
+16. **Patient Waiting is Mandatory**: Agent execution takes significant time (typically 10-30 minutes per phase, sometimes longer). The coordinator MUST:
+    - Wait patiently for `wait()` calls to complete
+    - NOT skip workflow steps due to perceived delays
+    - NOT assume agents have failed just because they're taking time
+    - Trust the timeout mechanisms defined in the skill
+
+17. **Use send_input for Clarification**: When agents need guidance or appear stuck, the coordinator MUST:
+    - Use `send_input()` to ask questions or provide clarification
+    - NOT skip the agent or move to next phase prematurely
+    - Give agents opportunity to respond before escalating
+    - Example: `send_input({ id: agent_id, message: "Please provide status update or clarify blockers" })`
+
+18. **No Workflow Shortcuts**: The coordinator MUST NOT:
+    - Skip phases or stages defined in the workflow
+    - Bypass required approval or review steps
+    - Execute dependent tasks before prerequisites complete
+    - Assume task completion without explicit agent callback
+    - Make up or fabricate agent results
+
+19. **Respect Long-Running Processes**: This is a complex multi-agent workflow that requires patience:
+    - Total execution time may range from 30-90 minutes or longer
+    - Each phase may take 10-30 minutes depending on complexity
+    - The coordinator must remain active and attentive throughout the entire process
+    - Do not terminate or skip steps due to time concerns

package/.codex/skills/team-perf-opt/instructions/agent-instruction.md

@@ -1,122 +1,122 @@
-## TASK ASSIGNMENT
-
-### MANDATORY FIRST STEPS
-1. Read shared discoveries: {session_folder}/discoveries.ndjson (if exists, skip if not)
-2. Read project context: .workflow/project-tech.json (if exists)
-3. Read task schema: .codex/skills/team-perf-opt/schemas/tasks-schema.md
-
----
-
-## Your Task
-
-**Task ID**: {id}
-**Title**: {title}
-**Description**: {description}
-**Role**: {role}
-**Bottleneck Type**: {bottleneck_type}
-**Priority**: {priority}
-**Target Files**: {target_files}
-
-### Previous Tasks' Findings (Context)
-{prev_context}
-
----
-
-## Execution Protocol
-
-1. **Read discoveries**: Load {session_folder}/discoveries.ndjson for shared exploration findings
-2. **Use context**: Apply previous tasks' findings from prev_context above
-3. **Execute by role**:
-
-   **If role = profiler**:
-   - Detect project type by scanning for framework markers:
-     - Frontend (React/Vue/Angular): render time, bundle size, FCP/LCP/CLS
-     - Backend Node (Express/Fastify/NestJS): CPU hotspots, memory, DB queries
-     - Native/JVM Backend (Cargo/Go/Java): CPU, memory, GC tuning
-     - CLI Tool: startup time, throughput, memory peak
-   - Trace hot code paths and CPU hotspots within target scope
-   - Identify memory allocation patterns and potential leaks
-   - Measure I/O and network latency where applicable
-   - Collect quantified baseline metrics (timing, memory, throughput)
-   - Rank top 3-5 bottlenecks by severity (Critical/High/Medium)
-   - Record evidence: file paths, line numbers, measured values
-   - Write `{session_folder}/artifacts/baseline-metrics.json` (metrics)
-   - Write `{session_folder}/artifacts/bottleneck-report.md` (ranked bottlenecks)
-
-   **If role = strategist**:
-   - Read bottleneck report and baseline from {session_folder}/artifacts/
-   - For each bottleneck, select optimization strategy by type:
-     - CPU: algorithm optimization, memoization, caching, worker threads
-     - MEMORY: pool reuse, lazy init, WeakRef, scope cleanup
-     - IO: batching, async pipelines, streaming, connection pooling
-     - NETWORK: request coalescing, compression, CDN, prefetching
-     - RENDERING: virtualization, memoization, CSS containment, code splitting
-     - DATABASE: index optimization, query rewriting, caching layer
-   - Prioritize by impact/effort: P0 (high impact+low effort) to P3
-   - Assign unique OPT-IDs (OPT-001, 002, ...) with non-overlapping file targets
-   - Define measurable success criteria (target metric value or improvement %)
-   - Write `{session_folder}/artifacts/optimization-plan.md`
-
-   **If role = optimizer**:
-   - Read optimization plan from {session_folder}/artifacts/optimization-plan.md
-   - Apply optimizations in priority order (P0 first)
-   - Preserve existing behavior -- optimization must not break functionality
-   - Make minimal, focused changes per optimization
-   - Add comments only where optimization logic is non-obvious
-   - Preserve existing code style and conventions
-
-   **If role = benchmarker**:
-   - Read baseline from {session_folder}/artifacts/baseline-metrics.json
-   - Read plan from {session_folder}/artifacts/optimization-plan.md
-   - Run benchmarks matching detected project type:
-     - Frontend: bundle size, render performance
-     - Backend: endpoint response times, memory under load, DB query times
-     - CLI: execution time, memory peak, throughput
-   - Run test suite to verify no regressions
-   - Collect post-optimization metrics matching baseline format
-   - Calculate improvement percentages per metric
-   - Compare against plan success criteria
-   - Write `{session_folder}/artifacts/benchmark-results.json`
-   - Set verdict: PASS (meets criteria) / WARN (partial) / FAIL (regression or criteria not met)
-
-   **If role = reviewer**:
-   - Read plan from {session_folder}/artifacts/optimization-plan.md
-   - Review changed files across 5 dimensions:
-     - Correctness: logic errors, race conditions, null safety
-     - Side effects: unintended behavior changes, API contract breaks
-     - Maintainability: code clarity, complexity increase, naming
-     - Regression risk: impact on unrelated code paths
-     - Best practices: idiomatic patterns, no optimization anti-patterns
-   - Write `{session_folder}/artifacts/review-report.md`
-   - Set verdict: APPROVE / REVISE / REJECT
-
-4. **Share discoveries**: Append exploration findings to shared board:
-   ```bash
-   echo '{"ts":"<ISO8601>","worker":"{id}","type":"<type>","data":{...}}' >> {session_folder}/discoveries.ndjson
-   ```
-5. **Report result**: Return JSON via report_agent_job_result
-
-### Discovery Types to Share
-- `bottleneck_found`: `{type, location, severity, description}` -- Bottleneck identified
-- `hotspot_found`: `{file, function, cpu_pct, description}` -- CPU hotspot
-- `memory_issue`: `{file, type, size_mb, description}` -- Memory problem
-- `io_issue`: `{operation, latency_ms, description}` -- I/O issue
-- `db_issue`: `{query, latency_ms, description}` -- Database issue
-- `file_modified`: `{file, change, lines_added}` -- File change recorded
-- `metric_measured`: `{metric, value, unit, context}` -- Metric measured
-- `pattern_found`: `{pattern_name, location, description}` -- Pattern identified
-- `artifact_produced`: `{name, path, producer, type}` -- Deliverable created
-
----
-
-## Output (report_agent_job_result)
-
-Return JSON:
-{
-  "id": "{id}",
-  "status": "completed" | "failed",
-  "findings": "Key discoveries and implementation notes (max 500 chars)",
-  "verdict": "PASS|WARN|FAIL|APPROVE|REVISE|REJECT or empty",
-  "artifacts_produced": "semicolon-separated artifact paths",
-  "error": ""
-}
+## TASK ASSIGNMENT
+
+### MANDATORY FIRST STEPS
+1. Read shared discoveries: {session_folder}/discoveries.ndjson (if exists, skip if not)
+2. Read project context: .workflow/project-tech.json (if exists)
+3. Read task schema: ~  or <project>/.codex/skills/team-perf-opt/schemas/tasks-schema.md
+
+---
+
+## Your Task
+
+**Task ID**: {id}
+**Title**: {title}
+**Description**: {description}
+**Role**: {role}
+**Bottleneck Type**: {bottleneck_type}
+**Priority**: {priority}
+**Target Files**: {target_files}
+
+### Previous Tasks' Findings (Context)
+{prev_context}
+
+---
+
+## Execution Protocol
+
+1. **Read discoveries**: Load {session_folder}/discoveries.ndjson for shared exploration findings
+2. **Use context**: Apply previous tasks' findings from prev_context above
+3. **Execute by role**:
+
+   **If role = profiler**:
+   - Detect project type by scanning for framework markers:
+     - Frontend (React/Vue/Angular): render time, bundle size, FCP/LCP/CLS
+     - Backend Node (Express/Fastify/NestJS): CPU hotspots, memory, DB queries
+     - Native/JVM Backend (Cargo/Go/Java): CPU, memory, GC tuning
+     - CLI Tool: startup time, throughput, memory peak
+   - Trace hot code paths and CPU hotspots within target scope
+   - Identify memory allocation patterns and potential leaks
+   - Measure I/O and network latency where applicable
+   - Collect quantified baseline metrics (timing, memory, throughput)
+   - Rank top 3-5 bottlenecks by severity (Critical/High/Medium)
+   - Record evidence: file paths, line numbers, measured values
+   - Write `{session_folder}/artifacts/baseline-metrics.json` (metrics)
+   - Write `{session_folder}/artifacts/bottleneck-report.md` (ranked bottlenecks)
+
+   **If role = strategist**:
+   - Read bottleneck report and baseline from {session_folder}/artifacts/
+   - For each bottleneck, select optimization strategy by type:
+     - CPU: algorithm optimization, memoization, caching, worker threads
+     - MEMORY: pool reuse, lazy init, WeakRef, scope cleanup
+     - IO: batching, async pipelines, streaming, connection pooling
+     - NETWORK: request coalescing, compression, CDN, prefetching
+     - RENDERING: virtualization, memoization, CSS containment, code splitting
+     - DATABASE: index optimization, query rewriting, caching layer
+   - Prioritize by impact/effort: P0 (high impact+low effort) to P3
+   - Assign unique OPT-IDs (OPT-001, 002, ...) with non-overlapping file targets
+   - Define measurable success criteria (target metric value or improvement %)
+   - Write `{session_folder}/artifacts/optimization-plan.md`
+
+   **If role = optimizer**:
+   - Read optimization plan from {session_folder}/artifacts/optimization-plan.md
+   - Apply optimizations in priority order (P0 first)
+   - Preserve existing behavior -- optimization must not break functionality
+   - Make minimal, focused changes per optimization
+   - Add comments only where optimization logic is non-obvious
+   - Preserve existing code style and conventions
+
+   **If role = benchmarker**:
+   - Read baseline from {session_folder}/artifacts/baseline-metrics.json
+   - Read plan from {session_folder}/artifacts/optimization-plan.md
+   - Run benchmarks matching detected project type:
+     - Frontend: bundle size, render performance
+     - Backend: endpoint response times, memory under load, DB query times
+     - CLI: execution time, memory peak, throughput
+   - Run test suite to verify no regressions
+   - Collect post-optimization metrics matching baseline format
+   - Calculate improvement percentages per metric
+   - Compare against plan success criteria
+   - Write `{session_folder}/artifacts/benchmark-results.json`
+   - Set verdict: PASS (meets criteria) / WARN (partial) / FAIL (regression or criteria not met)
+
+   **If role = reviewer**:
+   - Read plan from {session_folder}/artifacts/optimization-plan.md
+   - Review changed files across 5 dimensions:
+     - Correctness: logic errors, race conditions, null safety
+     - Side effects: unintended behavior changes, API contract breaks
+     - Maintainability: code clarity, complexity increase, naming
+     - Regression risk: impact on unrelated code paths
+     - Best practices: idiomatic patterns, no optimization anti-patterns
+   - Write `{session_folder}/artifacts/review-report.md`
+   - Set verdict: APPROVE / REVISE / REJECT
+
+4. **Share discoveries**: Append exploration findings to shared board:
+   ```bash
+   echo '{"ts":"<ISO8601>","worker":"{id}","type":"<type>","data":{...}}' >> {session_folder}/discoveries.ndjson
+   ```
+5. **Report result**: Return JSON via report_agent_job_result
+
+### Discovery Types to Share
+- `bottleneck_found`: `{type, location, severity, description}` -- Bottleneck identified
+- `hotspot_found`: `{file, function, cpu_pct, description}` -- CPU hotspot
+- `memory_issue`: `{file, type, size_mb, description}` -- Memory problem
+- `io_issue`: `{operation, latency_ms, description}` -- I/O issue
+- `db_issue`: `{query, latency_ms, description}` -- Database issue
+- `file_modified`: `{file, change, lines_added}` -- File change recorded
+- `metric_measured`: `{metric, value, unit, context}` -- Metric measured
+- `pattern_found`: `{pattern_name, location, description}` -- Pattern identified
+- `artifact_produced`: `{name, path, producer, type}` -- Deliverable created
+
+---
+
+## Output (report_agent_job_result)
+
+Return JSON:
+{
+  "id": "{id}",
+  "status": "completed" | "failed",
+  "findings": "Key discoveries and implementation notes (max 500 chars)",
+  "verdict": "PASS|WARN|FAIL|APPROVE|REVISE|REJECT or empty",
+  "artifacts_produced": "semicolon-separated artifact paths",
+  "error": ""
+}

package/.codex/skills/team-planex/SKILL.md

@@ -501,3 +501,41 @@ if (plannerAgent) {
 |---------|--------|
 | `check` / `status` | Show progress: planned / executing / completed / failed counts |
 | `resume` / `continue` | Re-enter loop from Phase 2 |
+
+
+---
+
+## Coordinator Role Constraints (Main Agent)
+
+**CRITICAL**: The coordinator (main agent executing this skill) is responsible for **orchestration only**, NOT implementation.
+
+15. **Coordinator Does NOT Execute Code**: The main agent MUST NOT write, modify, or implement any code directly. All implementation work is delegated to spawned team agents. The coordinator only:
+    - Spawns agents with task assignments
+    - Waits for agent callbacks
+    - Merges results and coordinates workflow
+    - Manages workflow transitions between phases
+
+16. **Patient Waiting is Mandatory**: Agent execution takes significant time (typically 10-30 minutes per phase, sometimes longer). The coordinator MUST:
+    - Wait patiently for `wait()` calls to complete
+    - NOT skip workflow steps due to perceived delays
+    - NOT assume agents have failed just because they're taking time
+    - Trust the timeout mechanisms defined in the skill
+
+17. **Use send_input for Clarification**: When agents need guidance or appear stuck, the coordinator MUST:
+    - Use `send_input()` to ask questions or provide clarification
+    - NOT skip the agent or move to next phase prematurely
+    - Give agents opportunity to respond before escalating
+    - Example: `send_input({ id: agent_id, message: "Please provide status update or clarify blockers" })`
+
+18. **No Workflow Shortcuts**: The coordinator MUST NOT:
+    - Skip phases or stages defined in the workflow
+    - Bypass required approval or review steps
+    - Execute dependent tasks before prerequisites complete
+    - Assume task completion without explicit agent callback
+    - Make up or fabricate agent results
+
+19. **Respect Long-Running Processes**: This is a complex multi-agent workflow that requires patience:
+    - Total execution time may range from 30-90 minutes or longer
+    - Each phase may take 10-30 minutes depending on complexity
+    - The coordinator must remain active and attentive throughout the entire process
+    - Do not terminate or skip steps due to time concerns

package/.codex/skills/team-planex-v2/SKILL.md

@@ -429,7 +429,7 @@ for (let wave = 1; wave <= maxWave; wave++) {
   spawn_agents_on_csv({
     csv_path: `${sessionFolder}/wave-${wave}.csv`,
     id_column: "id",
-    instruction: Read(".codex/skills/team-planex/instructions/agent-instruction.md"),
+    instruction: Read("~  or <project>/.codex/skills/team-planex/instructions/agent-instruction.md"),
     max_concurrency: maxConcurrency,
     max_runtime_seconds: 1200,
     output_csv_path: `${sessionFolder}/wave-${wave}-results.csv`,
@@ -597,3 +597,41 @@ Both planner and executor agents share the same discoveries.ndjson file:
 8. **Cleanup Temp Files**: Remove wave-{N}.csv after results are merged
 9. **Two-Wave Pipeline**: Wave 1 = Planning (PLAN-*), Wave 2 = Execution (EXEC-*)
 10. **DO NOT STOP**: Continuous execution until all waves complete or all remaining tasks are skipped
+
+
+---
+
+## Coordinator Role Constraints (Main Agent)
+
+**CRITICAL**: The coordinator (main agent executing this skill) is responsible for **orchestration only**, NOT implementation.
+
+15. **Coordinator Does NOT Execute Code**: The main agent MUST NOT write, modify, or implement any code directly. All implementation work is delegated to spawned team agents. The coordinator only:
+    - Spawns agents with task assignments
+    - Waits for agent callbacks
+    - Merges results and coordinates workflow
+    - Manages workflow transitions between phases
+
+16. **Patient Waiting is Mandatory**: Agent execution takes significant time (typically 10-30 minutes per phase, sometimes longer). The coordinator MUST:
+    - Wait patiently for `wait()` calls to complete
+    - NOT skip workflow steps due to perceived delays
+    - NOT assume agents have failed just because they're taking time
+    - Trust the timeout mechanisms defined in the skill
+
+17. **Use send_input for Clarification**: When agents need guidance or appear stuck, the coordinator MUST:
+    - Use `send_input()` to ask questions or provide clarification
+    - NOT skip the agent or move to next phase prematurely
+    - Give agents opportunity to respond before escalating
+    - Example: `send_input({ id: agent_id, message: "Please provide status update or clarify blockers" })`
+
+18. **No Workflow Shortcuts**: The coordinator MUST NOT:
+    - Skip phases or stages defined in the workflow
+    - Bypass required approval or review steps
+    - Execute dependent tasks before prerequisites complete
+    - Assume task completion without explicit agent callback
+    - Make up or fabricate agent results
+
+19. **Respect Long-Running Processes**: This is a complex multi-agent workflow that requires patience:
+    - Total execution time may range from 30-90 minutes or longer
+    - Each phase may take 10-30 minutes depending on complexity
+    - The coordinator must remain active and attentive throughout the entire process
+    - Do not terminate or skip steps due to time concerns

package/.codex/skills/team-quality-assurance/SKILL.md

@@ -774,3 +774,41 @@ QAGEN -> QARUN -> (if coverage < target) -> GC Loop Handler
 9. **Scout Feeds Strategy**: Scout findings flow into strategist via prev_context and discoveries.ndjson
 10. **Cleanup Temp Files**: Remove wave-{N}.csv after results are merged
 11. **DO NOT STOP**: Continuous execution until all waves complete or all remaining tasks are skipped
+
+
+---
+
+## Coordinator Role Constraints (Main Agent)
+
+**CRITICAL**: The coordinator (main agent executing this skill) is responsible for **orchestration only**, NOT implementation.
+
+15. **Coordinator Does NOT Execute Code**: The main agent MUST NOT write, modify, or implement any code directly. All implementation work is delegated to spawned team agents. The coordinator only:
+    - Spawns agents with task assignments
+    - Waits for agent callbacks
+    - Merges results and coordinates workflow
+    - Manages workflow transitions between phases
+
+16. **Patient Waiting is Mandatory**: Agent execution takes significant time (typically 10-30 minutes per phase, sometimes longer). The coordinator MUST:
+    - Wait patiently for `wait()` calls to complete
+    - NOT skip workflow steps due to perceived delays
+    - NOT assume agents have failed just because they're taking time
+    - Trust the timeout mechanisms defined in the skill
+
+17. **Use send_input for Clarification**: When agents need guidance or appear stuck, the coordinator MUST:
+    - Use `send_input()` to ask questions or provide clarification
+    - NOT skip the agent or move to next phase prematurely
+    - Give agents opportunity to respond before escalating
+    - Example: `send_input({ id: agent_id, message: "Please provide status update or clarify blockers" })`
+
+18. **No Workflow Shortcuts**: The coordinator MUST NOT:
+    - Skip phases or stages defined in the workflow
+    - Bypass required approval or review steps
+    - Execute dependent tasks before prerequisites complete
+    - Assume task completion without explicit agent callback
+    - Make up or fabricate agent results
+
+19. **Respect Long-Running Processes**: This is a complex multi-agent workflow that requires patience:
+    - Total execution time may range from 30-90 minutes or longer
+    - Each phase may take 10-30 minutes depending on complexity
+    - The coordinator must remain active and attentive throughout the entire process
+    - Do not terminate or skip steps due to time concerns

package/.codex/skills/team-review/SKILL.md

@@ -493,3 +493,41 @@ send_input({
 8. **Lifecycle Balance**: Every spawn_agent MUST have a matching close_agent (tracked in registry.json)
 9. **Cleanup Temp Files**: Remove wave-{N}.csv after results are merged
 10. **DO NOT STOP**: Continuous execution until all waves complete or all remaining tasks are skipped
+
+
+---
+
+## Coordinator Role Constraints (Main Agent)
+
+**CRITICAL**: The coordinator (main agent executing this skill) is responsible for **orchestration only**, NOT implementation.
+
+15. **Coordinator Does NOT Execute Code**: The main agent MUST NOT write, modify, or implement any code directly. All implementation work is delegated to spawned team agents. The coordinator only:
+    - Spawns agents with task assignments
+    - Waits for agent callbacks
+    - Merges results and coordinates workflow
+    - Manages workflow transitions between phases
+
+16. **Patient Waiting is Mandatory**: Agent execution takes significant time (typically 10-30 minutes per phase, sometimes longer). The coordinator MUST:
+    - Wait patiently for `wait()` calls to complete
+    - NOT skip workflow steps due to perceived delays
+    - NOT assume agents have failed just because they're taking time
+    - Trust the timeout mechanisms defined in the skill
+
+17. **Use send_input for Clarification**: When agents need guidance or appear stuck, the coordinator MUST:
+    - Use `send_input()` to ask questions or provide clarification
+    - NOT skip the agent or move to next phase prematurely
+    - Give agents opportunity to respond before escalating
+    - Example: `send_input({ id: agent_id, message: "Please provide status update or clarify blockers" })`
+
+18. **No Workflow Shortcuts**: The coordinator MUST NOT:
+    - Skip phases or stages defined in the workflow
+    - Bypass required approval or review steps
+    - Execute dependent tasks before prerequisites complete
+    - Assume task completion without explicit agent callback
+    - Make up or fabricate agent results
+
+19. **Respect Long-Running Processes**: This is a complex multi-agent workflow that requires patience:
+    - Total execution time may range from 30-90 minutes or longer
+    - Each phase may take 10-30 minutes depending on complexity
+    - The coordinator must remain active and attentive throughout the entire process
+    - Do not terminate or skip steps due to time concerns

package/.codex/skills/team-roadmap-dev/SKILL.md

@@ -643,3 +643,41 @@ const discoveries = Read(`${sessionDir}/discoveries.ndjson`)
 8. **Lifecycle Balance**: Every spawn_agent MUST have a matching close_agent (tracked in registry.json)
 9. **Cleanup Temp Files**: Remove wave-{N}.csv after results are merged
 10. **DO NOT STOP**: Continuous execution until all waves complete or all remaining tasks are skipped
+
+
+---
+
+## Coordinator Role Constraints (Main Agent)
+
+**CRITICAL**: The coordinator (main agent executing this skill) is responsible for **orchestration only**, NOT implementation.
+
+15. **Coordinator Does NOT Execute Code**: The main agent MUST NOT write, modify, or implement any code directly. All implementation work is delegated to spawned team agents. The coordinator only:
+    - Spawns agents with task assignments
+    - Waits for agent callbacks
+    - Merges results and coordinates workflow
+    - Manages workflow transitions between phases
+
+16. **Patient Waiting is Mandatory**: Agent execution takes significant time (typically 10-30 minutes per phase, sometimes longer). The coordinator MUST:
+    - Wait patiently for `wait()` calls to complete
+    - NOT skip workflow steps due to perceived delays
+    - NOT assume agents have failed just because they're taking time
+    - Trust the timeout mechanisms defined in the skill
+
+17. **Use send_input for Clarification**: When agents need guidance or appear stuck, the coordinator MUST:
+    - Use `send_input()` to ask questions or provide clarification
+    - NOT skip the agent or move to next phase prematurely
+    - Give agents opportunity to respond before escalating
+    - Example: `send_input({ id: agent_id, message: "Please provide status update or clarify blockers" })`
+
+18. **No Workflow Shortcuts**: The coordinator MUST NOT:
+    - Skip phases or stages defined in the workflow
+    - Bypass required approval or review steps
+    - Execute dependent tasks before prerequisites complete
+    - Assume task completion without explicit agent callback
+    - Make up or fabricate agent results
+
+19. **Respect Long-Running Processes**: This is a complex multi-agent workflow that requires patience:
+    - Total execution time may range from 30-90 minutes or longer
+    - Each phase may take 10-30 minutes depending on complexity
+    - The coordinator must remain active and attentive throughout the entire process
+    - Do not terminate or skip steps due to time concerns

package/.codex/skills/team-tech-debt/SKILL.md

@@ -668,3 +668,41 @@ Wave 3: TDVAL-001 (validator) -> 4-layer validation
 8. **GC Loop Bounded**: Maximum 3 fix-verify rounds before accepting current state
 9. **Worktree Isolation**: All fix execution happens in git worktree, not main branch
 10. **DO NOT STOP**: Continuous execution until all waves complete or all remaining tasks are skipped
+
+
+---
+
+## Coordinator Role Constraints (Main Agent)
+
+**CRITICAL**: The coordinator (main agent executing this skill) is responsible for **orchestration only**, NOT implementation.
+
+15. **Coordinator Does NOT Execute Code**: The main agent MUST NOT write, modify, or implement any code directly. All implementation work is delegated to spawned team agents. The coordinator only:
+    - Spawns agents with task assignments
+    - Waits for agent callbacks
+    - Merges results and coordinates workflow
+    - Manages workflow transitions between phases
+
+16. **Patient Waiting is Mandatory**: Agent execution takes significant time (typically 10-30 minutes per phase, sometimes longer). The coordinator MUST:
+    - Wait patiently for `wait()` calls to complete
+    - NOT skip workflow steps due to perceived delays
+    - NOT assume agents have failed just because they're taking time
+    - Trust the timeout mechanisms defined in the skill
+
+17. **Use send_input for Clarification**: When agents need guidance or appear stuck, the coordinator MUST:
+    - Use `send_input()` to ask questions or provide clarification
+    - NOT skip the agent or move to next phase prematurely
+    - Give agents opportunity to respond before escalating
+    - Example: `send_input({ id: agent_id, message: "Please provide status update or clarify blockers" })`
+
+18. **No Workflow Shortcuts**: The coordinator MUST NOT:
+    - Skip phases or stages defined in the workflow
+    - Bypass required approval or review steps
+    - Execute dependent tasks before prerequisites complete
+    - Assume task completion without explicit agent callback
+    - Make up or fabricate agent results
+
+19. **Respect Long-Running Processes**: This is a complex multi-agent workflow that requires patience:
+    - Total execution time may range from 30-90 minutes or longer
+    - Each phase may take 10-30 minutes depending on complexity
+    - The coordinator must remain active and attentive throughout the entire process
+    - Do not terminate or skip steps due to time concerns

package/.codex/skills/team-testing/SKILL.md

@@ -730,3 +730,41 @@ TESTGEN -> TESTRUN -> (if pass_rate < 0.95 OR coverage < target) -> GC Loop Hand
 8. **GC Loop Discipline**: Max 3 rounds per layer; never infinite-loop on coverage
 9. **Cleanup Temp Files**: Remove wave-{N}.csv after results are merged
 10. **DO NOT STOP**: Continuous execution until all waves complete or all remaining tasks are skipped
+
+
+---
+
+## Coordinator Role Constraints (Main Agent)
+
+**CRITICAL**: The coordinator (main agent executing this skill) is responsible for **orchestration only**, NOT implementation.
+
+15. **Coordinator Does NOT Execute Code**: The main agent MUST NOT write, modify, or implement any code directly. All implementation work is delegated to spawned team agents. The coordinator only:
+    - Spawns agents with task assignments
+    - Waits for agent callbacks
+    - Merges results and coordinates workflow
+    - Manages workflow transitions between phases
+
+16. **Patient Waiting is Mandatory**: Agent execution takes significant time (typically 10-30 minutes per phase, sometimes longer). The coordinator MUST:
+    - Wait patiently for `wait()` calls to complete
+    - NOT skip workflow steps due to perceived delays
+    - NOT assume agents have failed just because they're taking time
+    - Trust the timeout mechanisms defined in the skill
+
+17. **Use send_input for Clarification**: When agents need guidance or appear stuck, the coordinator MUST:
+    - Use `send_input()` to ask questions or provide clarification
+    - NOT skip the agent or move to next phase prematurely
+    - Give agents opportunity to respond before escalating
+    - Example: `send_input({ id: agent_id, message: "Please provide status update or clarify blockers" })`
+
+18. **No Workflow Shortcuts**: The coordinator MUST NOT:
+    - Skip phases or stages defined in the workflow
+    - Bypass required approval or review steps
+    - Execute dependent tasks before prerequisites complete
+    - Assume task completion without explicit agent callback
+    - Make up or fabricate agent results
+
+19. **Respect Long-Running Processes**: This is a complex multi-agent workflow that requires patience:
+    - Total execution time may range from 30-90 minutes or longer
+    - Each phase may take 10-30 minutes depending on complexity
+    - The coordinator must remain active and attentive throughout the entire process
+    - Do not terminate or skip steps due to time concerns

package/.codex/skills/team-uidesign/SKILL.md

@@ -727,3 +727,41 @@ Convergence: audit.score >= 8 AND audit.critical_count === 0
 8. **GC Loop Cap**: Max 2 generator-critic rounds between designer and reviewer
 9. **Cleanup Temp Files**: Remove wave-{N}.csv after results are merged
 10. **DO NOT STOP**: Continuous execution until all waves complete or all remaining tasks are skipped
+
+
+---
+
+## Coordinator Role Constraints (Main Agent)
+
+**CRITICAL**: The coordinator (main agent executing this skill) is responsible for **orchestration only**, NOT implementation.
+
+15. **Coordinator Does NOT Execute Code**: The main agent MUST NOT write, modify, or implement any code directly. All implementation work is delegated to spawned team agents. The coordinator only:
+    - Spawns agents with task assignments
+    - Waits for agent callbacks
+    - Merges results and coordinates workflow
+    - Manages workflow transitions between phases
+
+16. **Patient Waiting is Mandatory**: Agent execution takes significant time (typically 10-30 minutes per phase, sometimes longer). The coordinator MUST:
+    - Wait patiently for `wait()` calls to complete
+    - NOT skip workflow steps due to perceived delays
+    - NOT assume agents have failed just because they're taking time
+    - Trust the timeout mechanisms defined in the skill
+
+17. **Use send_input for Clarification**: When agents need guidance or appear stuck, the coordinator MUST:
+    - Use `send_input()` to ask questions or provide clarification
+    - NOT skip the agent or move to next phase prematurely
+    - Give agents opportunity to respond before escalating
+    - Example: `send_input({ id: agent_id, message: "Please provide status update or clarify blockers" })`
+
+18. **No Workflow Shortcuts**: The coordinator MUST NOT:
+    - Skip phases or stages defined in the workflow
+    - Bypass required approval or review steps
+    - Execute dependent tasks before prerequisites complete
+    - Assume task completion without explicit agent callback
+    - Make up or fabricate agent results
+
+19. **Respect Long-Running Processes**: This is a complex multi-agent workflow that requires patience:
+    - Total execution time may range from 30-90 minutes or longer
+    - Each phase may take 10-30 minutes depending on complexity
+    - The coordinator must remain active and attentive throughout the entire process
+    - Do not terminate or skip steps due to time concerns