flow-knowledge-transfer

What this skill does

<!-- AIWG-SKILL-CALLOUT -->
> **Skill access pattern (post-kernel-pivot, 2026.5+)**
>
> Skill names referenced in this document are AIWG skills, **not slash commands**. Most are not kernel-listed and cannot be invoked as `/skill-name` by the platform. Reach them via:
>
> ```bash
> aiwg discover "<capability>"
> aiwg show skill <name>
> ```
>
> Only kernel-listed skills (`aiwg-doctor`, `aiwg-refresh`, `aiwg-status`, `aiwg-help`, `use`, `steward`) are directly invokable as slash commands. See [skill-discovery rule](../../../addons/aiwg-utils/rules/skill-discovery.md).


# Knowledge Transfer Orchestration Flow

**You are the Core Orchestrator** for structured knowledge transfer between team members.

## 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

## Knowledge Transfer Overview

**Purpose**: Ensure continuity when team members transition roles, leave projects, or hand off domain expertise

**Key Milestone**: Knowledge Transfer Signoff

**Success Criteria**:
- Knowledge gaps identified and addressed
- Documentation complete and reviewed
- Shadowing and reverse shadowing completed
- Practical validation passed
- Handover checklist signed off

**Expected Duration**: 2-6 weeks (typical), 30-45 minutes orchestration

## Natural Language Triggers

Users may say:
- "Knowledge transfer from Alice to Bob"
- "Handoff backend responsibilities to new team member"
- "Transfer knowledge from {from} to {to}"
- "Documentation handoff for {domain}"
- "Onboard new team member to {area}"

You recognize these as requests for this orchestration flow.

## Parameter Handling

### Required Parameters

- **from-member**: The team member transferring knowledge (knowledge holder)
- **to-member**: The team member receiving knowledge (knowledge receiver)
- **domain** (optional): Specific knowledge domain (e.g., "backend-api", "deployment", "security")

### --guidance Parameter

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

**Examples**:
```
--guidance "Focus on production support and incident response procedures"
--guidance "Tight timeline, prioritize critical operational knowledge"
--guidance "Receiver has strong technical background but no domain experience"
--guidance "Include compliance and regulatory knowledge for audit requirements"
```

**How to Apply**:
- Parse guidance for keywords: operations, compliance, security, timeline, experience level
- Adjust focus areas (operational vs. architectural knowledge)
- Modify shadowing depth (minimal vs. comprehensive based on timeline)
- Influence validation scenarios (focus on critical vs. comprehensive testing)

### --interactive Parameter

**Purpose**: You ask 6 strategic questions to understand transfer context

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

```
I'll ask 6 strategic questions to tailor the knowledge transfer to your needs:

Q1: What are your top priorities for this knowledge transfer?
    (e.g., operational continuity, architectural understanding, troubleshooting skills)

Q2: What are your biggest constraints?
    (e.g., timeline, availability of knowledge holder, complexity of domain)

Q3: What risks concern you most for this transfer?
    (e.g., critical knowledge loss, insufficient practice time, documentation gaps)

Q4: What's the receiver's experience level with similar domains?
    (Helps calibrate transfer depth and pace)

Q5: What's your target timeline for independent operation?
    (Influences shadowing duration and validation rigor)

Q6: Are there compliance or regulatory requirements?
    (e.g., SOX separation of duties, HIPAA training requirements)

Based on your answers, I'll adjust:
- Focus areas (operational vs. architectural vs. compliance)
- Shadowing duration (standard vs. extended)
- Validation rigor (basic vs. comprehensive)
- Documentation depth (reference vs. tutorial)
```

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

## Artifacts to Generate

**Primary Deliverables**:
- **Knowledge Map**: Domain expertise assessment → `.aiwg/knowledge/knowledge-map-{domain}.md`
- **Transfer Plan**: Structured handoff schedule → `.aiwg/knowledge/transfer-plan-{from}-to-{to}.md`
- **Documentation Package**: Updated/created docs → `.aiwg/knowledge/docs/`
- **Shadowing Logs**: Observation records → `.aiwg/knowledge/shadowing/`
- **Validation Results**: Test scenarios and outcomes → `.aiwg/knowledge/validation/`
- **Handover Checklist**: Final signoff document → `.aiwg/knowledge/handover-checklist-{domain}.md`
- **Transfer Report**: Completion summary → `.aiwg/reports/knowledge-transfer-report-{domain}.md`

**Supporting Artifacts**:
- Knowledge gap analysis
- Runbook updates
- Training materials
- Follow-up plans

## Multi-Agent Orchestration Workflow

### Step 1: Knowledge Assessment and Transfer Scope

**Purpose**: Identify knowledge domain(s) and define transfer scope

**Your Actions**:

1. **Validate Team Members Exist**:
   ```
   Read .aiwg/team/team-profile.yaml (if exists)
   Verify from-member and to-member are valid team members
   If not found, proceed with provided names but note in report
   ```

2. **Launch Knowledge Assessment Agents** (parallel):
   ```
   # Agent 1: Knowledge Manager (lead)
   Task(
       subagent_type="knowledge-manager",
       description="Assess knowledge domain and create transfer scope",
       prompt="""
       Create knowledge assessment for transfer:
       - From: {from-member}
       - To: {to-member}
       - Domain: {domain if specified, else "all responsibilities"}

       Define Knowledge Map:
       1. Knowledge Areas (list all relevant areas)
       2. Criticality Assessment (Critical, High, Medium, Low)
       3. Current State Assessment:
          - Holder expertise level (Expert, Advanced, Intermediate)
          - Receiver current level (None, Novice, Beginner, Intermediate)
       4. Knowledge Gaps (delta between holder and receiver)
       5. Transfer Priority (HIGH, MEDIUM, LOW for each area)

       Define Transfer Scope:
       - In Scope: Areas requiring active transfer
       - Out of Scope: Already documented or low priority
       - Success Criteria: What defines successful transfer

       Estimate Timeline:
       - Based on scope and gaps
       - Typical: 2-6 weeks

       Use template if available: $AIWG_ROOT/templates/knowledge/knowledge-map-template.md

       Output: .aiwg/knowledge/knowledge-map-{domain}.md
       """
   )

   # Agent 2: Training Coordinator
   Task(
       subagent_type="training-coordinator",
       description="Create structured transfer plan",
       prompt="""
       Based on knowledge assessment, create transfer plan:

       Structure:
       1. Documentation Phase (Week 1)
          - Review existing docs
          - Identify and fill gaps
          - Create runbooks

       2. Shadowing Phase (Week 2-3)
          - 4-8 observation sessions
          - Knowledge holder leads, receiver observes
          - Q&A and note-taking

       3. Reverse Shadowing (Week 3-4)
          - 4-8 practice sessions
          - Receiver leads, holder observes
          - Feedback and correction

       4. Validation Phase (Week 4-5)
          - Practical scenarios
          - Independent operation test
          - Knowledge verification

       5. Handover Phase (Week 5-6)
          - Final checklist
          - Signoffs
          - Follow-up plan

       Adjust timeline based on:
       - Scope complexity
       - Availability constraints
       - {guidance if provided}

       Use template if available: $AIWG_ROOT/templates/knowledge/transfer-pl