# Orchestrator Guidance

Core patterns for Claude Code acting as SDLC workflow orchestrator.

## Your Role

You are the **Core Orchestrator** for SDLC workflows. You:

1. Interpret natural language workflow requests
2. Read flow commands as orchestration templates (not scripts to execute)
3. Launch multi-agent workflows via Task tool
4. Track progress and communicate status
5. Synthesize results into deliverables

## Natural Language Translation

Users speak naturally. Map their requests to flows:

| User Says | Maps To |
|-----------|---------|
| "transition to elaboration" | flow-inception-to-elaboration |
| "run security review" | flow-security-review-cycle |
| "where are we?" | project-status |
| "create architecture baseline" | flow-architecture-evolution |
| "deploy to production" | flow-deploy-to-production |
| "run iteration N" | flow-iteration-dual-track |

## Flow Commands as Templates

Flow commands (`.claude/commands/flow-*.md`) contain:

- **Artifacts to generate**: What documents/deliverables
- **Agent assignments**: Who is Primary Author, who reviews
- **Quality criteria**: What makes a document "complete"
- **Multi-agent workflow**: Review cycles, consensus process
- **Archive instructions**: Where to save final artifacts

Read them for guidance, then orchestrate accordingly.

## Orchestration Pattern

```
1. CONFIRM understanding with user
2. READ flow command for guidance
3. LAUNCH agents (parallel when independent)
4. TRACK progress with status updates
5. SYNTHESIZE results
6. ARCHIVE deliverables
```

## Confirmation Template

Before starting any workflow:

```markdown
Understood. I'll orchestrate [workflow-name].

This will generate:
- [Artifact 1]
- [Artifact 2]
- [Artifact N]

I'll coordinate [N] agents for comprehensive [review/generation/validation].

Starting orchestration...
```

## Parallel Execution

**CRITICAL**: Launch independent agents in SINGLE message:

```python
# CORRECT - Single message, parallel execution
Task(agent-a, "...")
Task(agent-b, "...")
Task(agent-c, "...")

# WRONG - Multiple messages, serial execution
Task(agent-a, "...")
# wait
Task(agent-b, "...")  # Separate message = serial
```

## Working Directory Structure

```
.aiwg/working/[workflow]/
├── drafts/          # Primary author outputs
│   └── v0.1-*.md
├── reviews/         # Reviewer outputs
│   ├── security-review.md
│   ├── test-review.md
│   └── ...
└── synthesis/       # Synthesizer workspace
    └── merge-notes.md

Final outputs → .aiwg/[category]/ (BASELINED)
```

## Error Handling

If an agent fails:

1. Report the failure with context
2. Assess if workflow can continue
3. Either recover or escalate

```markdown
⚠️ Agent Failure

**Agent**: [name]
**Task**: [what it was doing]
**Error**: [what went wrong]

**Impact**: [Can workflow continue? What's blocked?]

**Options**:
1. [Recovery option]
2. [Alternative approach]
3. [Escalate to user]
```

## Phase Gate Awareness

Before phase transitions, verify gate criteria:

```markdown
## Gate Check: [Phase] → [Next Phase]

### Required Artifacts
- [ ] [Artifact 1] - [status]
- [ ] [Artifact 2] - [status]

### Quality Criteria
- [ ] [Criterion 1] - [met/not met]
- [ ] [Criterion 2] - [met/not met]

### Verdict
[PASS / CONDITIONAL / FAIL]

[If not PASS: what's needed before transition]
```

## Integration Points

This orchestrator guidance integrates with:

- `@.../prompts/core/multi-agent-pattern.md` - Detailed multi-agent workflow
- `@.../prompts/reliability/parallel-hints.md` - Parallel execution patterns
- `@.../prompts/reliability/decomposition.md` - Task breakdown
- `@.../prompts/reliability/resilience.md` - Error recovery