flow-cross-team-sync

What this skill does

# Cross-Team Synchronization Flow

**You are the Core Orchestrator** for cross-team coordination and integration alignment.

## Your Role

**You orchestrate multi-agent workflows. You do NOT execute bash scripts.**

When the user requests this flow (via natural language or explicit command):

1. **Interpret the request** and confirm understanding
2. **Read this template** as your orchestration guide
3. **Extract agent assignments** and workflow steps
4. **Launch agents via Task tool** in correct sequence
5. **Synthesize results** and finalize artifacts
6. **Report completion** with summary

## Cross-Team Sync Overview

**Purpose**: Orchestrate synchronization, dependency management, and integration planning across multiple teams working on interconnected systems.

**Key Activities**:
- Dependency mapping (team-to-team dependencies)
- Sync cadence establishment (daily, weekly)
- Blocker escalation
- Integration planning
- Cross-team demos and validation

**Expected Duration**: Initial setup 2-3 hours, ongoing syncs 1 hour weekly, orchestration 20-30 minutes

## Natural Language Triggers

Users may say:
- "Sync with {team}"
- "Coordinate teams"
- "Cross-team sync"
- "Team alignment meeting"
- "Set up team coordination"
- "Map team dependencies"
- "Establish team sync cadence"
- "Resolve cross-team blockers"

You recognize these as requests for this orchestration flow.

## Parameter Handling

### Team Parameters

**Primary inputs**:
- `team-a`: First team name (required)
- `team-b`: Second team name (required)
- `sync-frequency`: Optional frequency (weekly, bi-weekly, default: weekly)

### --guidance Parameter

**Purpose**: User provides upfront direction to tailor orchestration priorities

**Examples**:
```
--guidance "High API dependencies, need tight integration coordination"
--guidance "Teams in different time zones, prefer async communication"
--guidance "Critical launch deadline, daily sync needed for next 2 weeks"
--guidance "New teams, need extra focus on knowledge sharing and patterns"
```

**How to Apply**:
- Parse guidance for keywords: integration, timezone, deadline, knowledge
- Adjust sync frequency (daily for critical periods)
- Modify meeting structure (async-friendly for timezone issues)
- Add knowledge sharing emphasis (for new teams)

### --interactive Parameter

**Purpose**: You ask 6 strategic questions to understand team dynamics

**Questions to Ask** (if --interactive):

```
I'll ask 6 strategic questions to tailor cross-team synchronization:

Q1: What are the main integration points between teams?
    (e.g., APIs, shared databases, event streams, UI components)

Q2: How critical are the dependencies?
    (Helps determine sync frequency and escalation urgency)

Q3: What's the current blocker resolution time?
    (Helps set appropriate SLAs and escalation paths)

Q4: What are the teams' time zones and availability?
    (Influences meeting scheduling and async strategies)

Q5: What's your timeline pressure?
    (Daily sync for critical periods vs. weekly for normal pace)

Q6: What collaboration tools do teams use?
    (Slack, Teams, Jira, GitHub - affects communication setup)

Based on your answers, I'll adjust:
- Sync frequency (daily, weekly, bi-weekly)
- Meeting structure (sync vs. async emphasis)
- Escalation paths (SLAs and ownership)
- Knowledge sharing approach
```

**Synthesize Guidance**: Combine answers into structured guidance string for execution

## Artifacts to Generate

**Primary Deliverables**:
- **Dependency Map**: Component ownership and integration points → `.aiwg/team/dependency-map-{team-a}-{team-b}.md`
- **Integration Contracts**: API specifications and change protocol → `.aiwg/team/integration-contracts/`
- **Sync Meeting Agenda**: Structured meeting template → `.aiwg/team/sync-agenda-{team-a}-{team-b}.md`
- **Blocker Tracker**: Active blockers with SLAs → `.aiwg/team/blocker-tracker.md`
- **Escalation Matrix**: Clear escalation paths → `.aiwg/team/escalation-matrix.md`
- **Cross-Team Sync Report**: Health metrics and recommendations → `.aiwg/reports/cross-team-sync-report.md`

**Supporting Artifacts**:
- Meeting notes archive
- Demo recordings/summaries
- Reusable patterns documentation

## Multi-Agent Orchestration Workflow

### Step 1: Dependency Mapping and Integration Points

**Purpose**: Identify components owned by each team and map dependencies

**Your Actions**:

1. **Gather Context**:
   ```
   Read existing artifacts if present:
   - .aiwg/architecture/software-architecture-doc.md
   - .aiwg/requirements/use-case-*.md
   - Any existing team documentation
   ```

2. **Launch Dependency Analysis Agents** (parallel):
   ```
   # Agent 1: System Analyst - Component Analysis
   Task(
       subagent_type="system-analyst",
       description="Map component ownership and dependencies",
       prompt="""
       Analyze architecture and identify:

       For Team A ({team-a}):
       - Components owned
       - Services maintained
       - Data stores managed
       - External dependencies

       For Team B ({team-b}):
       - Components owned
       - Services maintained
       - Data stores managed
       - External dependencies

       Map dependencies:
       - Team A → Team B dependencies
       - Team B → Team A dependencies
       - Shared resources
       - External system touchpoints

       Classify each dependency:
       - Type: API, Database, Event Stream, File System
       - Criticality: BLOCKING, NON-BLOCKING
       - Status: ACTIVE, PLANNED, DEPRECATED

       Create dependency matrix showing all relationships.

       Output: .aiwg/working/team/dependency-analysis-draft.md
       """
   )

   # Agent 2: Integration Engineer - Technical Integration
   Task(
       subagent_type="integration-engineer",
       description="Define integration points and contracts",
       prompt="""
       Based on component analysis, define integration points:

       For each integration point:
       1. Integration ID and name
       2. Type (REST API, GraphQL, Event Stream, Database)
       3. Owner team
       4. Consumer team(s)
       5. Criticality (BLOCKING vs NON-BLOCKING)
       6. Current status (STABLE, IN_DEVELOPMENT, PLANNED)

       Define integration contracts:
       - API endpoints and methods
       - Data schemas
       - Error handling
       - Rate limits and SLAs
       - Authentication/authorization

       Document change protocol:
       - Breaking vs non-breaking changes
       - Notice period required
       - Version support policy
       - Migration requirements

       Output: .aiwg/working/team/integration-points-draft.md
       """
   )
   ```

3. **Synthesize Dependency Map**:
   ```
   Task(
       subagent_type="documentation-synthesizer",
       description="Create unified dependency map",
       prompt="""
       Read drafts:
       - .aiwg/working/team/dependency-analysis-draft.md
       - .aiwg/working/team/integration-points-draft.md

       Create comprehensive Dependency Map including:

       1. Component Ownership
          - Team A components with descriptions
          - Team B components with descriptions

       2. Dependency Matrix
          - Team A → Team B dependencies table
          - Team B → Team A dependencies table
          - Criticality and status for each

       3. Integration Points Detail
          - Detailed specifications for each IP
          - SLAs and performance requirements
          - Change management protocol

       4. Critical Path Dependencies
          - Dependencies that block progress
          - Impact analysis if not resolved

       5. Dependency Risks
          - Risk assessment table
          - Mitigation strategies

       Use clear tables and structured format.

       Output: .aiwg/team/dependency-map-{team-a}-{team-b}.md
       """
   )
   ```

**Communicate Progress**:
```
✓ Initialized dependency mapping
⏳ Analyzing team components and dependencies...
✓ Dependency map complete: .aiwg/team/dependency-map-{team-a}-{