메뉴
Conductor workflow patterns for multi-phase orchestration including planning, implementation, review cycles, pause points, and handoffs. Use for lifecycle management, delegation, and state tracking.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/kennedym-ds/copilot_orchestrator --skill conductor-lifecycle명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
Runtime budget enforcement for conductor workflows. Tracks model tier usage, delegation count, and estimated token cost across phases. Provides soft/hard limits with escalation patterns to prevent runaway sessions.
Agent-to-agent routing patterns for autonomous delegation via #runSubagent. Defines keyword matching, context templates, model preferences, escalation rules, and invocation guardrails. Use for routing decisions, subagent dispatch, delegation context preparation, and handoff target selection.
WCAG 2.1 Level AA compliance patterns for semantic HTML, ARIA, keyboard navigation, and screen reader compatibility. Use for accessibility audits, ARIA reviews, and POUR principle validation.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | conductor-lifecycle |
| description | Conductor workflow patterns for multi-phase orchestration including planning, implementation, review cycles, pause points, and handoffs. Use for lifecycle management, delegation, and state tracking. |
| user-invocable | true |
| argument-hint | [task description to walk through the conductor lifecycle for] |
Provides conductor workflow patterns for multi-phase orchestration including planning, implementation, review cycles, pause points, and handoffs.
When running under copilot CLI, prefer native slash commands over manual equivalents:
/fleet — parallel subagent execution (DEEP/ULTRADEEP + teams-enabled only)./tasks — visibility into background subagents./compact — emit at every phase transition to preserve context budget (see memory-management skill)./model — downshift to Haiku for Fast-tier delegates, upshift via security-review prompt override./remote — for long-running ULTRADEEP sessions.This skill teaches the conductor agent how to manage complex multi-phase workflows through structured lifecycle stages: Planning → Implementation → Review → Completion. It covers pause point enforcement, subagent delegation patterns, state tracking, artifact persistence, and handoff protocols that maintain context across the orchestration lifecycle.
The conductor coordinates specialized agents (planner, implementer, reviewer, researcher, support personas) while enforcing mandatory checkpoints for human approval after plans and reviews. This skill provides the operational patterns that transform user requests into systematic, auditable, phased execution.
This skill is relevant when:
artifacts/ folderObjective: Clarify scope, gather context, draft multi-phase plan
Pattern:
1. Summarize user request and constraints
2. Identify unknowns requiring research
3. Delegate to `researcher` subagent if needed:
#runSubagent researcher "Gather context on [technology/pattern/API]"
4. Delegate to `planner` subagent:
#runSubagent planner "Create multi-phase plan for [objective]. Include risks, dependencies, rollback strategy."
5. Present plan using docs/templates/plan.md structure
6. **PAUSE POINT:** Wait for user approval before proceeding
State Tracking:
Objective: Execute approved plan phase-by-phase with testing
Pattern:
For each phase:
1. Mark phase as "in-progress" in todo list
2. Delegate to `implementer` subagent:
#runSubagent implementer "Implement Phase N: [objective]. Files: [list]. Apply TDD: write tests first, then implementation. Validate with [scripts]."
3. After implementation, delegate to `reviewer`:
#runSubagent reviewer "Review Phase N changes. Check: correctness, test coverage, style compliance, security. Provide severity-tagged findings."
4. If reviewer APPROVED → create phase-complete.md artifact
5. If reviewer CHANGES_REQUIRED → iterate with implementer
6. **PAUSE POINT:** User commits changes, confirms ready for next phase
State Tracking:
Objective: Quality gates with severity-tagged findings
Pattern:
After each phase implementation:
1. Collect changed files and diff summary
2. Invoke reviewer with acceptance criteria:
#runSubagent reviewer "Review [files] for [phase objective]. Acceptance: [criteria]. Tag findings: BLOCKER, MAJOR, MINOR, NIT."
3. Parse verdict: APPROVED | CHANGES_REQUIRED | INSUFFICIENT_CONTEXT
4. If BLOCKER/MAJOR findings → iterate with implementer
5. If APPROVED → proceed to phase completion
Severity Levels:
Objective: Consolidate results, surface follow-up tasks
Pattern:
When all phases complete:
1. Compile plan-complete.md using docs/templates/plan-complete.md
2. Invoke support personas for final reviews:
- Security review: #runSubagent security "Review [changes] for security posture"
- Performance review: #runSubagent performance "Analyze [changes] for runtime/memory impact"
- Documentation: #runSubagent docs "Generate user-facing docs for [feature]"
3. Surface follow-up tasks, risks, recommendations
4. Provide rollback instructions if needed
State Tracking:
Objective: Iterative data analysis with round-based progress
Trigger Detection:
Pattern:
1. Detect DS-Star query → research handoff:
#runSubagent researcher "Gather context on [data question]. Dataset: [path]. Identify schema, data quality, relevant features."
2. Plan the analysis approach:
#runSubagent planner "Design iterative analysis plan for [objective]. Include methodology, success criteria, rounds."
3. Implementation rounds (max 10 rounds, 30-min timeout):
#runSubagent implementer "Execute analysis round [N]. Objective: [step]. Dataset: [path]. TDD approach."
4. Track verdict per round: INSUFFICIENT | PARTIAL | SUFFICIENT
5. On SUFFICIENT → documentation handoff:
#runSubagent docs "Create data analysis report from pipeline_state.json"
6. Surface methodology, findings, recommendations
State Tracking:
Mandatory Pause Points:
Pause Point Pattern:
**🛑 PAUSE POINT**
I've completed [stage]. Before proceeding, please:
1. [Action 1: e.g., review plan.md]
2. [Action 2: e.g., commit Phase N changes]
3. Reply "proceed" to continue or provide feedback
**Current State:**
- Phase: [current]
- Progress: [N of M]
- Artifacts: [list of created files]
Local Artifacts Folder:
artifacts/
├── plans/{feature-name}/
│ ├── plan.md
│ ├── phase-1-complete.md
│ ├── phase-N-complete.md
│ └── plan-complete.md
├── reviews/{date}-{feature}.md
├── research/{topic}.md
├── security/{date}-{scope}.md
└── sessions/{session-id}.json
Artifact Naming:
artifacts/plans/{feature-slug}/plan.mdartifacts/reviews/{YYYY-MM-DD}-{feature-slug}.mdartifacts/sessions/{session-id}.jsonTemplate Usage:
docs/templates/plan.mddocs/templates/phase-complete.mddocs/templates/plan-complete.mdInclude in every conductor response:
### State Tracking
**Current Phase:** Planning | Implementation | Review | Complete | DS-Star
**Plan Progress:** {completed} of {total} phases
**Last Action:** {summary of most recent step}
**Next Action:** {immediate recommended step or pause point}
Delegation Pattern:
1. Summarize context before delegation (preserve continuity)
2. Invoke subagent: #runSubagent {agent-name} "{detailed prompt}"
3. Parse subagent response, extract key information
4. Update state tracking based on outcome
5. Determine next action (continue, pause, escalate)
Context Preservation:
Common Delegations:
| Agent | When to Delegate | Prompt Pattern |
|---|---|---|
planner | Need multi-phase plan | "Create phased plan for [objective]. Include risks, dependencies, rollback." |
implementer | Execute plan phase | "Implement Phase N: [objective]. Files: [list]. TDD approach. Validate with [scripts]." |
reviewer | After implementation | "Review [files] for [phase]. Acceptance: [criteria]. Tag findings by severity." |
researcher | Gather context | "Research [technology/pattern]. Find: API docs, best practices, examples." |
security | Security review | "Review [changes] for threat model, compliance impacts." |
performance | Performance analysis | "Analyze [changes] for runtime, memory, cost implications." |
docs | Documentation | "Generate user guide for [feature]. Include: setup, usage, troubleshooting." |
rubber-duck | Problem-solving | "User is stuck on [problem]. Help them think through it via Socratic questioning." |
User Request: "Add OAuth2 authentication to our API"
Conductor Response:
I'll orchestrate OAuth2 integration through a multi-phase plan.
### State Tracking
**Current Phase:** Planning
**Plan Progress:** 0 of ? phases
**Last Action:** Received feature request
**Next Action:** Delegate to planner for multi-phase plan
Let me engage the planner to create a structured implementation plan.
#runSubagent planner "Create multi-phase implementation plan for adding OAuth2 authentication to API. Include: 1) Research OAuth2 providers (Auth0, Okta, Cognito), 2) Design token flow (authorization code + PKCE), 3) Implement auth middleware, 4) Add token validation, 5) Update API endpoints with auth checks, 6) Create integration tests. Consider: security best practices, existing session management, backward compatibility. Identify risks and rollback strategy."
[After planner responds...]
I've created a 5-phase implementation plan (see artifacts/plans/oauth2-integration/plan.md):
**Phase 1:** Research & Provider Selection (1 day)
**Phase 2:** Auth Middleware Implementation (2 days)
**Phase 3:** Endpoint Protection (2 days)
**Phase 4:** Testing & Validation (1 day)
**Phase 5:** Documentation & Rollout (1 day)
**🛑 PAUSE POINT**
Please review the plan at artifacts/plans/oauth2-integration/plan.md. Reply "proceed" to start Phase 1 or provide feedback for adjustments.
### State Tracking
**Current Phase:** Planning (awaiting approval)
**Plan Progress:** 0 of 5 phases
**Last Action:** Presented OAuth2 integration plan
**Next Action:** Await user approval to proceed with Phase 1
User Reply: "Proceed with Phase 1"
Conductor Response:
Starting Phase 1: Research & Provider Selection
### State Tracking
**Current Phase:** Implementation (Phase 1 of 5)
**Plan Progress:** 1 of 5 phases
**Last Action:** User approved plan
**Next Action:** Delegate to researcher for OAuth2 provider analysis
#runSubagent researcher "Research OAuth2 providers for API integration. Compare: Auth0, Okta, AWS Cognito. Evaluate: pricing, developer experience, token flow support (authorization code + PKCE), SDK quality, rate limits, enterprise features. Provide recommendation with rationale."
[After researcher responds...]
Research complete. Recommendation: Auth0 (best DX, generous free tier, excellent Node.js SDK).
Now implementing Phase 1 deliverables:
#runSubagent implementer "Implement Phase 1: OAuth2 Provider Selection. Create docs/architecture/oauth2-design.md documenting: 1) Provider choice (Auth0) with rationale, 2) Token flow diagram (authorization code + PKCE), 3) Integration points with existing API. Apply TDD: create test plan before implementation."
[After implementer responds...]
Phase 1 implementation complete. Requesting review:
#runSubagent reviewer "Review Phase 1 deliverables: docs/architecture/oauth2-design.md. Acceptance criteria: 1) Provider choice justified, 2) Token flow clearly documented, 3) Integration points identified, 4) Security considerations addressed. Tag findings by severity (BLOCKER, MAJOR, MINOR, NIT)."
[After reviewer responds with APPROVED verdict...]
**Phase 1 Complete** ✓
Created artifacts/plans/oauth2-integration/phase-1-complete.md with:
- Deliverables: oauth2-design.md (architecture document)
- Review: APPROVED with 0 blockers, 1 minor suggestion (document token expiry strategy)
- Validation: Design reviewed by security perspective
**🛑 PAUSE POINT**
Please commit Phase 1 changes and reply "proceed to phase 2" when ready.
### State Tracking
**Current Phase:** Implementation (Phase 1 complete, awaiting commit)
**Plan Progress:** 1 of 5 phases (20%)
**Last Action:** Completed Phase 1, reviewer approved
**Next Action:** Await user commit confirmation, then proceed to Phase 2
User Request: "Analyze customer churn data to identify retention factors"
Conductor Response:
Detected data science query. Delegating to DS-Star workflow.
### State Tracking
**Current Phase:** DS-Star Analysis
**Plan Progress:** Round 0/10
**Last Action:** Identified data analysis request
**Next Action:** Delegate to researcher agent
#runSubagent researcher "Gather context on customer churn data. Dataset: data/customers.csv. Identify schema, data quality, relevant features for retention analysis."
[Researcher gathers context, then planner designs analysis approach...]
#runSubagent implementer "Execute DS-Star analysis round 1. Analyze customer churn factors. Objective: Identify key drivers of customer retention. Dataset: data/customers.csv. Success criteria: Statistical significance p<0.05, actionable insights."
DS-Star analysis complete after 4 rounds (verdict: SUFFICIENT).
Key findings from pipeline_state.json:
- Top retention factors: engagement score (p<0.001), support response time (p<0.003), feature adoption rate (p<0.008)
- Churn risk model: 82% accuracy, 0.79 AUC-ROC
- Recommendations: Prioritize engagement campaigns, improve support SLA, enhance onboarding for low-adoption users
Creating final documentation:
#runSubagent docs "Generate data analysis report from artifacts/sessions/pipeline_state.json. Include: executive summary, methodology, findings (with visualizations), recommendations, limitations. Audience: retention team and product leadership."
[After docs agent completes...]
**Analysis Complete**
Deliverables:
- artifacts/research/customer-churn-analysis.md (full report)
- artifacts/sessions/pipeline_state.json (methodology and raw results)
### State Tracking
**Current Phase:** Complete
**Plan Progress:** DS-Star workflow finished (4 rounds)
**Last Action:** Created final analysis report
**Next Action:** User reviews findings and implements retention strategies
User Request: "Can we add Phase 6 for A/B testing?"
Conductor Response:
This is a **scope expansion** request requiring approval.
**Current Plan:** 5 phases (OAuth2 implementation)
**Proposed Addition:** Phase 6 (A/B testing framework)
**Impact Analysis:**
- Timeline: +2 days (estimated)
- Risk: Introduces external dependency (A/B testing service)
- Benefit: Gradual rollout with metrics
**🛑 PAUSE POINT**
Before expanding scope, I need explicit approval:
1. Review current plan: artifacts/plans/oauth2-integration/plan.md
2. Confirm: Do you want to add Phase 6 (A/B testing) to this plan?
3. Alternative: Complete current 5 phases, then create separate A/B testing task
**Options:**
A. Approve scope expansion → I'll engage planner to add Phase 6
B. Defer A/B testing → Complete original 5 phases first
C. Modify → Adjust the new phase requirements
Please choose A, B, or C.
### State Tracking
**Current Phase:** Implementation (Phase 3 of 5)
**Plan Progress:** 3 of 5 phases (60%)
**Last Action:** User requested scope expansion
**Next Action:** Await approval decision on Phase 6 addition
instructions/workflows/conductor.instructions.md.github/agents/conductor.agent.md — primary orchestration persona and handoff surface.github/skills/delegation-routing/SKILL.md — keyword-based agent routing, escalation rules, invocation guardrailsdocs/templates/plan.md, docs/templates/phase-complete.md, docs/templates/plan-complete.mdAGENTS.mddocs/workflows/ds-star-integration.mdartifacts/README.mddocs/guides/session-analytics.md