antigravity-claudekit/skills/ck-ccs-delegation/SKILL.md

name, description

name	description
ck-ccs-delegation	Orchestrates parallel and sequential agent delegation via Manager Surface. Activate when user says 'delegate this task', 'run agents in parallel', 'spawn subagents', 'coordinate multiple agents', 'parallel execution', or 'multi-agent workflow'. Accepts task descriptions, dependency graphs, and parallelization strategies.

Overview

Defines patterns for decomposing work across multiple agents using the Manager Surface. Handles parallel dispatch, sequential chaining, dependency management, and result aggregation.

When to Use

• Task can be split into independent subtasks that benefit from parallel execution
• Complex workflows requiring sequential agent chaining (plan → implement → test → review)
• Research tasks needing multiple specialized agents working simultaneously
• Large implementation broken into non-conflicting file ownership zones
• Orchestrating plan phases across parallel developer agents

Don't Use When

• Task is simple and fits within a single agent's context
• Subtasks have tight coupling making parallelization harmful
• Sequential dependency chain is unavoidable and short
• Debugging a single focused issue (use ck-debug instead)

Steps / Instructions

1. Decompose the Work

Identify parallelizable vs sequential segments:

Sequential chain (dependencies):
  Research → Plan → Implement → Test → Review

Parallel dispatch (independent):
  Phase 1A: auth module    ─┐
  Phase 1B: data models    ─┼─ all start simultaneously
  Phase 1C: API routes     ─┘
  Phase 2: integration tests (after 1A, 1B, 1C complete)

2. Define File Ownership

Each parallel agent must own non-overlapping files:

Agent A owns:
- src/auth/**
- src/middleware/auth.ts

Agent B owns:
- src/models/**
- prisma/schema.prisma

Agent C owns:
- src/routes/**
- src/controllers/**

3. Dispatch Parallel Agents via Manager Surface

For independent parallel tasks, dispatch all at once:

Manager Surface dispatch:
  Agent 1: "Implement authentication module. Work context: /path/to/project.
            File ownership: src/auth/**, src/middleware/auth.ts
            Reports: /path/to/project/plans/reports/"

  Agent 2: "Implement data models. Work context: /path/to/project.
            File ownership: src/models/**, prisma/schema.prisma
            Reports: /path/to/project/plans/reports/"

  Agent 3: "Implement API routes. Work context: /path/to/project.
            File ownership: src/routes/**, src/controllers/**
            Reports: /path/to/project/plans/reports/"

4. Sequential Chaining Pattern

Pass outputs between agents:

Step 1: dispatch researcher agent
  → researcher writes report to plans/reports/research-report.md

Step 2: dispatch planner agent (after researcher completes)
  → planner reads research report, creates plan in plans/

Step 3: dispatch parallel developer agents (after planner completes)
  → each developer reads their phase file from plans/

Step 4: dispatch tester agent (after all developers complete)
  → tester runs full test suite

Step 5: dispatch reviewer agent (after tests pass)
  → reviewer reads changed files and reports

5. Delegation Prompt Template

Always include in each agent's prompt:

1. Work context path — git root of the project
2. Reports path — where to write output reports
3. Plans path — where plan files live
4. File ownership — explicit list of owned files
5. Phase file — path to the phase spec the agent implements

Task: Implement Phase 2 - Database Models

Work context: /path/to/project
Reports: /path/to/project/plans/reports/
Plans: /path/to/project/plans/
Phase file: /path/to/project/plans/260216-1400-feature/phase-02-models.md

File ownership (modify ONLY these):
- src/models/user.ts
- src/models/post.ts
- prisma/schema.prisma

Dependencies complete: Phase 1 (env setup) is done.

6. Aggregate Results

After all parallel agents complete:

1. Read each agent's report from plans/reports/
2. Check for file ownership violations
3. Verify success criteria from each phase
4. Run integration tests across all implemented modules
5. Dispatch reviewer if all tests pass

7. Conflict Resolution

If agents report file conflicts:

1. Stop all dependent phases
2. Identify which agents touched overlapping files
3. Assign clear ownership to one agent
4. Re-run the affected phase with corrected ownership

Notes

• Always include work context and reports path in delegation prompts
• File ownership boundaries prevent merge conflicts
• Parallel agents should never read files owned by sibling parallel agents
• Report aggregation is the orchestrator's responsibility, not individual agents