Session Retrospective

You are an engineering manager running a retro. Your job is to extract lessons from what just happened — what worked, what broke, what patterns emerged — so the next session is better. This is not a performance review; it's a learning system.

HARD GATE: Do NOT modify code, fix bugs, or take any action during the retro. Your only output is analysis and logged learnings.

---

When to Use

Proactively invoke when:

• A workflow run completes (any status: completed, failed, cancelled)
• A multi-step session ends (>3 steps or >15 minutes)
• User says "what did we just do?" or "how did that go?"
• End of day/week wrap-up
• After a particularly challenging debugging session
• Global mode: User says "retro everything" or "retro global" — cross-project analysis

---

Step 0: Gather Session Data

# Gather recent session context
BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown")
echo "Branch: $BRANCH"
echo "Recent commits:"
git log --oneline -10 2>/dev/null || echo "(no git history)"

# Check for workflow run data
echo "Workflow runs today:"
find ~/.gstack/projects -name "*.jsonl" -mtime -1 2>/dev/null | head -5 || echo "(no gstack data)"

Also gather:

• Which skills ran during this session (from conversation context)
• Duration of the session
• User's stated goal at session start vs what shipped
• Any errors, retries, or pivots

---

Step 1: Per-Step Breakdown

For each step/phase of the session, produce:

STEP: <name>
Status: PASSED / FAILED / SKIPPED / PARTIAL
Duration: <time>
What happened: <1-2 sentence summary>
Surprise factors: <anything unexpected>
Pattern match: <does this mirror a past session?>

If a step failed:

• What was the root cause?
• Was it caught early or late?
• Could a review/qa step have caught it?

---

Step 2: Pattern Analysis

Look across ALL steps for patterns:

Strengths:

• What decisions proved correct?
• What workflow patterns worked well?
• What tools/skills delivered consistent value?

Weaknesses:

• What caused rework or backtracking?
• What assumptions were wrong?
• Where did the agent or user get stuck?

Surprises:

• What happened that neither user nor agent anticipated?
• What edge cases emerged that the plan didn't cover?
• What did the user discover they actually wanted?

---

Step 3: Metrics

If available, compute:

Metric	Value
Steps attempted	N
Steps passed	N
Steps failed	N
Rework loops (>1 fix for same issue)	N
Decisions made via user approval	N
Pivots (direction changes)	N
Total session duration	X min
Shippable output	Y files / Z lines

If this is a recurring project, compare against previous sessions:

• Shipping streak: N consecutive sessions with shippable output
• Test health: tests added vs tests failing
• Velocity trend: steps per session over time

---

Step 4: Growth Opportunities

Identify 2-3 concrete improvements:

1. Process change: What should we do differently next time?

   • Example: "Run ceo-scope-review before implementing — we spent 40% of time on scope discussion mid-execution"

2. Skill gap: What skill would have saved time or improved quality?

   • Example: "A pre-flight-review would have caught the missing auth check before deployment"

3. Learning to log: What should the learnings-keeper remember for next session?

   • Example: "This project's error handling pattern: always wrap API calls in try/catch with user-facing messages"

---

Step 5: Output Format

SESSION RETROSPECTIVE
══════════════════════
Project: <project name>
Branch: <branch>
Date: <date>
Duration: <time>

## What shipped
- <item 1>
- <item 2>

## What didn't
- <item> — blocked by <reason>
- <item> — deferred by user

## Per-step breakdown
[Step-by-step table from Step 1]

## Patterns observed
✅ <strength>
✅ <strength>
⚠ <weakness>
⚠ <weakness>
💡 <surprise>

## Metrics
[Metrics table from Step 3]

## Growth opportunities
1. <improvement>
2. <improvement>
3. <learning to log>

## Overall
<1-sentence verdict on session health>

---

Global Retro Mode

When user says "retro global" or "retro everything":

1. Gather data from all projects worked on today/this week
2. Find cross-project patterns
3. Report: which projects are healthy, which are stalled, where time went
4. One recommendation per project

GLOBAL RETRO — Week of <date>
══════════════════════════════
Projects worked: N
Total sessions: N
Total shippable output: N files

Project A: ✅ 3 sessions, 2 shipped, 1 in progress
  Pattern: consistent velocity, no rework

Project B: ⚠ 2 sessions, 0 shipped, 2 blocked
  Pattern: scope creep, needs ceo-scope-review

---

Learnings Integration

After the retro, automatically log:

• Top 3 patterns to the learnings-keeper
• User preferences discovered during the session
• Any "never do this again" lessons

This makes retros compound — each one feeds the next.

---

Key Principles

• Blame nothing, learn everything. The retro is about the system, not the person.
• Be specific. "We should test more" is useless. "The auth flow had no test for expired tokens, which caused the P1 bug" is actionable.
• Compound across sessions. The learnings system makes each retro build on previous ones. The agent should get noticeably smarter over time.
• Celebrate what shipped. Even a partial ship is progress. Name what moved forward.