Mid-Session Save 150 Protocol

Core Principle: Don't wait for session end to save. Checkpoint early, checkpoint often.

What This Skill Does

This skill provides quick checkpoints during active work:

• Capture current progress without full handoff
• Track what worked and what didn't (raw material for lessons)
• Persist lessons learned so far
• Update session state for continuity
• Can be invoked multiple times per development cycle

Key Insight: Progress Log as Lesson Source

The session progress log captures:

• ✅ What worked (successful approaches)
• ❌ What didn't work (failed attempts, dead ends)
• 🔄 What was tried (experiments, approaches tested)

This raw data becomes the source for extracting lessons later. Don't just save "what's done" — save the journey including failures.

When to Use This Skill

Triggers:

• AFTER EVERY USER INTERACTION: Record progress, decisions, or new findings before or after responding.
• Context window running low (but not ending session)
• Significant progress made (feature partially done)
• Important lesson learned (don't risk losing it)
• Before complex/risky operation
• User says "save progress", "checkpoint", "зберегти"
• Every 30-45 min of active work (recommended cadence)

NOT for:

• Full session end → use 72-close-session-150
• Just recording a single lesson → use 73-close-lessons-learn-150

The 150% Checkpoint Rule

• 100% Core: What changed + current state
• 50% Enhancement: Key learnings + immediate next step

Quick Checkpoint Protocol

Step 1: IDENTIFY CHANGES

What happened since last checkpoint:

• Files touched
• Decisions made
• Problems solved

Step 2: LOG SESSION PROGRESS (Critical!)

Track the journey, not just the destination:

• ✅ What worked — successful approaches, solutions that fixed issues
• ❌ What didn't work — failed attempts, dead ends, wrong assumptions
• 🔄 What was tried — experiments, approaches tested, hypotheses
• 💡 Why it worked/failed — root cause understanding (if known)

Write to: .sessions/SESSION_[date]-[name].md in ## Progress Log section Purpose: Raw material for extracting lessons later Protocol: ALWAYS append new checkpoints to the existing log. Use a horizontal rule --- or a timestamp header to separate new entries from old ones. NEVER clear the previous log entries within the same session file.

Step 3: CAPTURE LESSONS (if ready)

If a clear lesson emerged:

• Add to MEMORY.md Lessons (Inbox)
• Don't skip this — context loss = lesson loss
• If lesson not yet clear, progress log will preserve the data

Step 4: UPDATE SESSION LOG STATE

Current state in the session log:

• Update the ## Current State block (or add it if missing)
• Keep it brief and current

Step 5: QUICK CONTEXT SAVE

Final state in .sessions/SESSION_[date]-[name].md:

• Current focus + next action
• Ready for immediate continuation

Output Format: Mid-Session Checkpoint

⏱️ **MID-SESSION CHECKPOINT**

**Checkpoint:** #N | [date - HH"MM]
**Task:** [Current task name]

## Since Last Checkpoint
- [Change 1]
- [Change 2]

## Progress Log (What Worked / What Didn't)
✅ Worked:
- [Successful approach 1]
- [Solution that fixed issue]

❌ Didn't Work:
- [Failed attempt 1] — reason: [why it failed]
- [Dead end 2] — reason: [wrong assumption]

🔄 Tried:
- [Experiment/hypothesis tested]

## Current State
- Working on: [Current focus]
- Status: [Progress indicator]

## Lessons Captured
- [Lesson added to MEMORY.md, or "Pending — data in progress log"]

## Next Action
→ [Immediate next step]

---
✅ Checkpoint saved | Ready to continue

Ultra-Quick Format

When time is very short (< 1 min):

⏱️ CHECKPOINT #N

Done: [What completed]
Worked: [What succeeded]
Failed: [What didn't work + why]
Now: [Current state]  
Next: [Immediate action]

What Gets Updated

Location	What	When
.sessions/SESSION_[date]-[name].md	Quick state + Progress Log	Every checkpoint
MEMORY.md Lessons (Inbox)	New learnings	Only if lessons are clear

Progress Log → Lessons Pipeline

Checkpoint #1: Log what worked/failed (raw data)
       ↓
Checkpoint #2: More data accumulated
       ↓
Checkpoint #3: Pattern emerges → Extract lesson → MEMORY.md Lessons (Inbox)
       ↓
Session End: Review all progress logs → Extract remaining lessons

Key principle: Not every checkpoint produces a lesson. The progress log is the raw material — lessons are extracted when patterns become clear.

Checkpoint Cadence Recommendations

Work Type	Recommended Interval
Bug fixing	After each bug solved
Feature development	Every 30-45 min
Refactoring	After each file/component
Investigation	After major finding
Complex operation	Before and after

Comparison with Related Skills

Skill	Purpose	When
74-mid-session-save-150	Quick checkpoint	During work, multiple times
72-close-session-150	Full handoff	End of session
73-close-lessons-learn-150	Record lesson	After success confirmation

Operational Rules

1. CHECKPOINT OFTEN: Better too many than too few
2. LOG FAILURES TOO: What didn't work is as valuable as what did
3. LESSONS FIRST: Don't lose learnings
4. BE BRIEF: Quick saves, not essays
5. STAY CURRENT: Update, don't accumulate
6. IMMEDIATE NEXT: Always know what's next
7. PROGRESS = RAW DATA: Not every checkpoint needs a lesson — collect data first

Example: Development Cycle with Checkpoints

Start Session
    ↓
Load context (session-start-memory)
    ↓
Work on Feature Part 1
    ↓
⏱️ CHECKPOINT #1 (45 min in)
   └─ Progress: ✅ API route works | ❌ Hook failed (stale closure)
    ↓
Work on Feature Part 2
    ↓
⏱️ CHECKPOINT #2 (problem solved)
   └─ Progress: ✅ useCallback fixed closure | Pattern emerges → LESSON CAPTURED
    ↓
Work on Feature Part 3
    ↓
⏱️ CHECKPOINT #3 (context getting low)
   └─ Progress: 🔄 Trying SSR approach | ❌ hydration mismatch
    ↓
Continue or End Session
    ↓
Close session (close-session-150)
   └─ Review all progress logs → Extract lessons from ❌ patterns

Example Progress Log Entry

## Progress Log

### Checkpoint #1 — 14:30
✅ Worked:
- API route returns correct data
- Zod schema validates input

❌ Didn't Work:
- Direct state update in useEffect — caused infinite loop
- Reason: dependency array included computed object

🔄 Tried:
- useMemo for computed dependency — testing now

### Checkpoint #2 — 15:15
✅ Worked:
- useMemo solved the loop — stable reference now
- Component renders correctly

❌ Didn't Work:
- (none this round)

💡 Lesson extracted: "Never use computed objects in useEffect deps — use useMemo or extract IDs"

Failure Modes & Recovery

Failure	Detection	Recovery
No checkpoints	Lost context when resuming	Reconstruct from files, git, tests
Stale checkpoint	Info outdated	Update before continuing
Lost lesson	Repeated same mistake	Document with extra context
Too verbose	Checkpoint took too long	Use ultra-quick format
Only logged success	Repeated failed approach	Log ❌ failures with reasons
No progress log	Can't extract lessons at session end	Always log worked/didn't work

---

Remember: Checkpoints are cheap. Lost context is expensive. When in doubt, checkpoint.