Session Wrap

Session Wrap Skill

Comprehensive session wrap-up workflow with multi-agent analysis.

Execution Flow

┌─────────────────────────────────────────────────────┐
│  1. Check Git Status                                │
├─────────────────────────────────────────────────────┤
│  2. Phase 1: 4 Analysis Agents (Parallel)           │
│     ┌─────────────────┬─────────────────┐           │
│     │  doc-updater    │  automation-    │           │
│     │  (docs update)  │  scout          │           │
│     ├─────────────────┼─────────────────┤           │
│     │  learning-      │  followup-      │           │
│     │  extractor      │  suggester      │           │
│     └─────────────────┴─────────────────┘           │
├─────────────────────────────────────────────────────┤
│  3. Phase 2: Validation Agent (Sequential)          │
│     ┌───────────────────────────────────┐           │
│     │       duplicate-checker           │           │
│     │  (Validate Phase 1 proposals)     │           │
│     └───────────────────────────────────┘           │
├─────────────────────────────────────────────────────┤
│  4. Integrate Results & AskUserQuestion             │
├─────────────────────────────────────────────────────┤
│  5. Execute Selected Actions                        │
└─────────────────────────────────────────────────────┘

Step 1: Check Git Status

git status --short
git diff --stat HEAD~3 2>/dev/null || git diff --stat

Step 2: Phase 1 - Analysis Agents (Parallel)

Execute 4 agents in parallel (single message with 4 Task calls).

Session Summary (Provide to all agents)

Session Summary:
- Work: [Main tasks performed in session]
- Files: [Created/modified files]
- Decisions: [Key decisions made]

Parallel Execution

Task(
    subagent_type="doc-updater",
    description="Document update analysis",
    prompt="[Session Summary]\n\nAnalyze if CLAUDE.md, context.md need updates."
)

Task(
    subagent_type="automation-scout",
    description="Automation pattern analysis",
    prompt="[Session Summary]\n\nAnalyze repetitive patterns or automation opportunities."
)

Task(
    subagent_type="learning-extractor",
    description="Learning points extraction",
    prompt="[Session Summary]\n\nExtract learnings, mistakes, and new discoveries."
)

Task(
    subagent_type="followup-suggester",
    description="Follow-up task suggestions",
    prompt="[Session Summary]\n\nSuggest incomplete tasks and next session priorities."
)

Agent Roles

Step 3: Phase 2 - Validation Agent (Sequential)

Run after Phase 1 completes (dependency on Phase 1 results).

Task(
    subagent_type="duplicate-checker",
    description="Phase 1 proposal validation",
    prompt="""
Validate Phase 1 analysis results.

## doc-updater proposals:
[doc-updater results]

## automation-scout proposals:
[automation-scout results]

Check if proposals duplicate existing docs/automation:
1. Complete duplicate: Recommend skip
2. Partial duplicate: Suggest merge approach
3. No duplicate: Approve for addition
"""
)

Step 4: Integrate Results

## Wrap Analysis Results

### Documentation Updates
[doc-updater summary]
- Duplicate check: [duplicate-checker feedback]

### Automation Suggestions
[automation-scout summary]
- Duplicate check: [duplicate-checker feedback]

### Learning Points
[learning-extractor summary]

### Follow-up Tasks
[followup-suggester summary]

Step 5: Action Selection

AskUserQuestion(
    questions=[{
        "question": "Which actions would you like to perform?",
        "header": "Wrap Options",
        "multiSelect": true,
        "options": [
            {"label": "Create commit (Recommended)", "description": "Commit changes"},
            {"label": "Update CLAUDE.md", "description": "Document new knowledge/workflows"},
            {"label": "Create automation", "description": "Generate skill/command/agent"},
            {"label": "Skip", "description": "End without action"}
        ]
    }]
)

Step 6: Execute Selected Actions

Execute only the actions selected by user.

---

Quick Reference

When to Use

• End of significant work session
• Before switching to different project
• After completing a feature or fixing a bug

When to Skip

• Very short session with trivial changes
• Only reading/exploring code
• Quick one-off question answered

Arguments

• Empty: Proceed interactively (full workflow)
• Message provided: Use as commit message and commit directly

Additional Resources

See references/multi-agent-patterns.md for detailed orchestration patterns.

Multi-Agent Orchestration Patterns

Detailed patterns for designing multi-agent workflows in Claude Code.

Core Principles

"Agent architecture should reflect the dependency graph of the task"

— Anthropic Multi-Agent Research

If subtasks don't read or modify each other's state, run them parallel. If previous output is next input, run them sequential.

Parallel vs Sequential Decision Criteria

Anthropic's 6 Composable Patterns

2-Phase Pipeline Pattern

For workflows generating proposals that need validation:

Phase 1: Analysis/Generation (Parallel)
┌──────────┬──────────┬──────────┐
│ Agent A  │ Agent B  │ Agent C  │  ← Independent analysis
└────┬─────┴────┬─────┴────┬─────┘
     │          │          │
     └──────────┼──────────┘
                ↓
Phase 2: Validation (Sequential)
┌─────────────────────────────────┐
│         Validator Agent         │  ← Validate Phase 1 results
└─────────────────────────────────┘

Application Examples

Session wrap workflow:

• Phase 1: doc-updater, automation-scout, learning-extractor, followup-suggester (parallel)
• Phase 2: duplicate-checker (sequential)

Code review workflow:

• Phase 1: security-reviewer, style-checker, performance-analyzer (parallel)
• Phase 2: final-reviewer (sequential)

Research workflow:

• Phase 1: source-finder, fact-checker, perspective-gatherer (parallel)
• Phase 2: synthesizer (sequential)

State Management Principles

❌ Avoid:
- Mutable state shared between concurrent agents
- Assuming synchronous updates across agent boundaries
- Assuming independence without explicit verification

✅ Recommend:
- Isolate agents as much as possible
- Pass state explicitly via output_key
- Define conflict resolution strategy for result aggregation
- Pass lightweight references (not full data)

Anti-Patterns

Model Selection for Agents

Implementing in Claude Code

Parallel Execution

Send multiple Task calls in a single message:

# All 4 agents start simultaneously
Task(subagent_type="agent-a", prompt="...")
Task(subagent_type="agent-b", prompt="...")
Task(subagent_type="agent-c", prompt="...")
Task(subagent_type="agent-d", prompt="...")

Sequential Execution

Wait for previous result before next call:

# First call
result_1 = Task(subagent_type="agent-a", prompt="...")

# Use result_1 in next call
Task(subagent_type="agent-b", prompt=f"Validate: {result_1}")

Hybrid (2-Phase)

# Phase 1: Parallel
Task(subagent_type="analyzer-1", prompt="...")
Task(subagent_type="analyzer-2", prompt="...")
Task(subagent_type="analyzer-3", prompt="...")

# Wait for all Phase 1 results

# Phase 2: Sequential (uses Phase 1 results)
Task(
    subagent_type="validator",
    prompt=f"""
    Validate these proposals:

    Analyzer 1: {result_1}
    Analyzer 2: {result_2}
    Analyzer 3: {result_3}
    """
)

Agent Design for Multi-Agent Systems

Clear Boundaries

Each agent should have:

• Single responsibility: One clear focus area
• Defined inputs: What it expects to receive
• Structured output: Consistent format for downstream consumption
• No side effects: Don't modify state other agents depend on

Communication Protocol

## Agent Output Format

### Summary
[One-line summary]

### Detailed Findings
[Structured analysis]

### Recommendations
[Actionable items with priorities]

### Confidence
[Self-assessment of analysis quality]

Scaling Considerations

When to Add More Agents

✅ Add agent when:

• Distinct expertise domain needed
• Independent analysis possible
• Clear boundary definable
• Reduces complexity vs. single agent

❌ Don't add agent when:

• Same expertise as existing agent
• Would create tight coupling
• Simple prompt modification sufficient
• Adds latency without value

Performance Optimization

1. Minimize Phase 2 agents: Validation should be lightweight 2. Right-size Phase 1: 3-5 parallel agents typically optimal 3. Use haiku for validation: Fast, cheap, sufficient for checking 4. Batch where possible: Combine related analyses in single agent

References

• Anthropic Multi-Agent Research
• Azure AI Agent Design Patterns
• Building AI Agents - Evaluator-Optimizer Pattern