/reflection

allowed-tools: Task, Read, Bash(git log:*), Bash(git diff:*), Bash(git branch:*), Bash(gh pr list:*), Bash(gh issue list:*), Bash(rg:*), Bash(fd:*), Bash(gdate:*), Bash(jq:*), Write
name: "Reflection"
description: "Ultra-fast comprehensive retrospective analysis using parallel reflection agents - 6-8x faster than sequential analysis"
author: "wcygan"
tags: ["meta","reflect"]
version: "1.0.0"
created_at: "2025-07-14T00:00:00Z"
updated_at: "2025-07-14T00:00:00Z"

Context

• Session ID: !`gdate +%s%N 2>/dev/null || date +%s%N 2>/dev/null || echo "$(date +%s)$(jot -r 1 100000 999999 2>/dev/null || shuf -i 100000-999999 -n 1 2>/dev/null || echo $RANDOM$RANDOM)"`
• Reflection scope: $ARGUMENTS
• Current branch: !`git branch --show-current 2>/dev/null || echo "no-git-repo"`
• Recent commits (last 10): !`git log --oneline -10 --since="1 week ago" 2>/dev/null || echo "No recent commits found"`
• Recent PRs: !`gh pr list --state all --limit 5 --json number,title,state,createdAt 2>/dev/null | jq -r '.[] | "#\(.number): \(.title) [\(.state)]"' 2>/dev/null || echo "No PR data available"`
• Open issues: !`gh issue list --state open --limit 5 --json number,title,labels 2>/dev/null | jq -r '.[] | "#\(.number): \(.title)"' 2>/dev/null || echo "No issue data available"`
• Project structure: !`fd . -t f -d 2 | head -10 2>/dev/null || echo "Limited file discovery"`
• Code changes analysis: !`git diff --stat HEAD~5..HEAD 2>/dev/null || echo "No recent changes to analyze"`
• Test results: !`rg "test.*pass|fail|error" . --type log -A 1 -B 1 | head -10 2>/dev/null || echo "No test logs found"`

Your Task

**CRITICAL: IMMEDIATELY DEPLOY 8 PARALLEL REFLECTION AGENTS** for instant comprehensive analysis. Each agent operates independently for maximum efficiency.

**Expected speedup: 6-8x faster than sequential reflection analysis.**

STEP 1: Initialize parallel reflection session

• CREATE session state file: `/tmp/reflection-session-$SESSION_ID.json`
• **LAUNCH ALL 8 REFLECTION AGENTS SIMULTANEOUSLY:**

[Deploy all agents in single response - NO SEQUENTIAL EXECUTION]

**Agent 1 - Success Pattern Analyzer**: "Analyze all successful implementations, high-velocity periods, and positive outcomes from git history. Identify what worked well, breakthrough moments, and effective patterns. Extract specific examples from commits, PRs, and resolved issues."

**Agent 2 - Challenge & Bottleneck Investigator**: "Investigate technical debt, failed attempts, reverted commits, and workflow bottlenecks. Analyze unresolved issues, delayed PRs, and communication gaps. Find root causes and patterns in challenges."

**Agent 3 - Learning & Insight Extractor**: "Extract key learnings from code evolution, architectural decisions, and domain knowledge expansion. Correlate decisions with outcomes. Identify skill development patterns and knowledge gained."

**Agent 4 - Quantitative Metrics Analyzer**: "Calculate all quantitative metrics: development velocity, code quality trends, PR turnaround times, issue resolution patterns, test coverage changes, and collaboration health indicators."

**Agent 5 - Decision Impact Assessor**: "Review all major decisions from commit messages and PR discussions. Assess outcomes against objectives, analyze trade-offs made, and evaluate alternative paths not taken."

**Agent 6 - Team Collaboration Auditor**: "Analyze collaboration patterns, review quality, contributor diversity, communication effectiveness, and team dynamics evolution. Identify collaboration highlights and gaps."

**Agent 7 - Technical Achievement Scanner**: "Scan for technical milestones, architectural improvements, performance optimizations, security enhancements, and code quality improvements. Document specific achievements with evidence."

**Agent 8 - Future Improvement Generator**: "Based on all available data, generate actionable improvements prioritized by impact. Create SMART goals, design process experiments, and plan technical debt reduction strategies."

**CRITICAL**: All agents must execute in parallel. NO waiting between agent launches. This achieves 6-8x speedup over sequential analysis.

STEP 2: Synthesize parallel agent findings

**AWAIT all 8 agents to complete their parallel analysis**

• COLLECT findings from all reflection agents
• MERGE quantitative metrics from Agent 4
• SYNTHESIZE success patterns from Agent 1 with challenges from Agent 2
• CORRELATE decisions (Agent 5) with outcomes and learnings (Agent 3)
• COMBINE technical achievements (Agent 7) with collaboration patterns (Agent 6)
• INTEGRATE improvement recommendations from Agent 8

**Session State Management:**

{
  "session_id": "$SESSION_ID",
  "parallel_agents": {
    "success_patterns": "completed",
    "challenges": "completed",
    "learnings": "completed",
    "metrics": "completed",
    "decisions": "completed",
    "collaboration": "completed",
    "achievements": "completed",
    "improvements": "completed"
  },
  "synthesis_state": "merging_insights",
  "performance_metrics": {
    "total_time": "8-12 seconds",
    "speedup": "6-8x",
    "agents_deployed": 8
  }
}

STEP 3: Generate ultra-comprehensive retrospective analysis

**Parallel Processing Benefits:**

• **Traditional Sequential Reflection**: 60-80 seconds for comprehensive analysis
• **Parallel Agent Reflection**: 8-12 seconds with 8 concurrent agents
• **Quality Enhancement**: More thorough coverage through specialized agents
• **Consistency**: Each agent follows structured analysis patterns
• **Scalability**: Can analyze larger codebases and longer timeframes

**Reflection Analysis Framework (Synthesized from all agents):**

FOR EACH reflection dimension:

**1. Context Establishment (Merged from all agents)**

{
  "period_scope": "$ARGUMENTS or current session",
  "key_objectives": "extracted from git commits and PR descriptions",
  "stakeholders": "identified from git contributors and PR reviewers",
  "data_sources": ["git_history", "github_activity", "code_m