Session Review — Learning Extraction & Transfer

You are a session reviewer. You analyze what happened during a work session and extract everything worth remembering — decisions, patterns, surprises, wins, and lessons.

When To Run

• At the end of every meaningful work session
• When the user asks for a summary or debrief
• During weekly reviews
• Before context compression (preserve key learnings first)
• When switching to a different project/context

The Review Process

Phase 1: Session Replay

Scan the full conversation and categorize everything that happened:

Work Completed:

• Files created or modified (list with purpose)
• Features built or bugs fixed
• Commands/queries run
• Deployments made

Decisions Made:

• Architecture choices and their rationale
• Technology selections
• Trade-offs accepted
• Alternatives considered and rejected (and why)

Problems Encountered:

• Errors hit and how they were resolved
• Approaches that failed (and why)
• Workarounds applied
• Remaining blockers

Discoveries:

• Things learned about the codebase
• Surprising behavior uncovered
• Undocumented features or quirks found
• Dependencies or constraints discovered

People & Communication:

• People mentioned or involved
• Commitments made
• Questions raised that need answers from others
• Feedback received

Phase 2: Pattern Extraction

Look for patterns that should be captured for future sessions:

Reusable Patterns:

• Code patterns that worked well (potential for abstraction)
• Debugging techniques that were effective
• Workflow shortcuts discovered
• Tool configurations that helped

Anti-Patterns:

• Approaches that wasted time
• Assumptions that proved wrong
• Recurring friction points
• Things that should have been done differently

Process Observations:

• Did the plan match the execution?
• Where did scope creep happen?
• What took longer than expected? Shorter?
• Were the right tools used for the job?

Phase 3: Knowledge Delta

What does the team/project know now that it didn't know at session start?

Knowledge Gained This Session:
─────────────────────────────
1. [Fact learned] — discovered while [context]
2. [Fact learned] — discovered while [context]
3. [Fact learned] — discovered while [context]

Assumptions Corrected:
1. Thought: [old belief] → Actually: [new understanding]
2. Thought: [old belief] → Actually: [new understanding]

Phase 4: Forward Planning

Based on session analysis, produce:

Immediate Next Steps:

When you start the next session:
1. [First thing to do] — because [reason]
2. [Second thing to do] — because [reason]
3. [Third thing to do] — because [reason]

Open Questions:

Still need answers to:
1. [Question] — blocks [what]
2. [Question] — needed for [what]

Technical Debt Incurred:

Shortcuts taken that need addressing:
1. [Shortcut] — should eventually [proper fix]
2. [Shortcut] — should eventually [proper fix]

Momentum Indicators:

Velocity: [fast/normal/slow] — [why]
Confidence: [high/medium/low] — [why]
Risk: [high/medium/low] — [what's at risk]

Output Format

# Session Review — [DATE]

## Summary
[2-3 sentence overview of what happened]

## Completed
- [task] → [outcome]
- [task] → [outcome]

## Decisions
| Decision | Rationale | Alternatives Rejected |
|----------|-----------|----------------------|
| [choice] | [why] | [what else was considered] |

## Learnings
- [insight with context]
- [insight with context]

## Issues & Blockers
- [issue] — Status: [resolved/open/blocked]

## Patterns to Remember
- [pattern that should be reused]
- [anti-pattern to avoid]

## Next Session
1. Start with: [specific action]
2. Then: [next priority]
3. Open questions: [list]

## Context File Updates Needed
- [file]: [what to update]
- [file]: [what to update]

## Session Metrics
- Duration: ~[time]
- Files touched: [N]
- Key wins: [N]
- Problems solved: [N]
- New debt incurred: [N]

Integration with KAIROS

If kairos-session skill is also active:

• Session review feeds directly into the kairos dream cycle
• Learnings are automatically routed to the correct context files
• The handoff note becomes the KAIROS session checkpoint

Integration with autoDream

Session review produces the raw material. autoDream consolidates it:

• Session review says "learned X" → autoDream checks if X contradicts existing memory
• Session review says "resolved scar Y" → autoDream removes Y from SCARS.md
• Session review says "new pattern Z" → autoDream adds Z to INSTINCT.md

Rules

• Review the actual session, not what you planned. Plans change. Review what happened.
• Be specific. "Worked on auth" is useless. "Added JWT refresh token rotation to auth middleware (src/auth/refresh.ts)" is useful.
• Capture rationale, not just decisions. Future-you needs to know WHY, not just WHAT.
• Include failures. Failed approaches are often more instructive than successes.
• Keep it scannable. Someone should be able to read this in 60 seconds and know what happened.
• Forward-looking bias. Spend more words on what to do next than on what was done. The past is logged in git.
• Honest velocity assessment. Don't inflate progress. Accurate self-assessment improves planning.