Park and Pickup (Part 5: Session Continuity)

~12 minutes to read. ~2 hours to implement if you’re following along.

What This Is

This documents the session management system I built for Claude Code + Obsidian over a 5-hour session on January 17, 2026. It solves the “where was I?” problem when picking up work sessions hours or days later.

The system has two commands:

/park - End a session by documenting open loops (Cal Newport’s “shutdown complete” ritual)
/pickup - Resume a session with full context restored

This is Part 5 of my Claude Code + Obsidian series. See Part 1 for the foundation.

The Problem: Mental Residue

The familiar feeling: You’re deep in a coding session or writing project. Making progress. Then you have to stop - dinner, meeting, bedtime, whatever. You tell yourself “I’ll pick this up tomorrow.”

Tomorrow comes. You open your editor or terminal. And: “Where was I?”

You scan recent files. Check git history. Try to reconstruct your mental state. 5-10 minutes wasted. Sometimes longer if you were in the middle of something complex.

Worse: if you don’t trust that you’ll remember where you left off, you keep working past optimal stopping time. Just one more thing. Let me finish this. The work expands because the handoff is broken.

Cal Newport calls this mental residue - the cognitive load of incomplete tasks that your mind keeps active in the background. You can’t truly rest because some part of your brain is holding onto “remember to…”.

With Claude Code sessions, this gets worse:

Session names are cryptic (based on last message)
Can’t link sessions together
Conversations aren’t documented in your vault
No explicit capture of open loops

You close a Claude session and immediately feel: “Did I document what needs doing next? Will I remember this conversation happened?”

The temptation: Keep working. Don’t stop. Avoid the handoff friction entirely.

That’s what I was feeling 5 hours into today’s implementation session.

The Solution: Park and Pickup

The core insight: Separate parking from pickup.

Parking (end of session):

Generate session summary (what was accomplished, key decisions, open loops)
Automatically lint/refactor/proofread all modified files
Write summary to dated archive file
Update project status
Display “shutdown complete” confirmation

Pickup (start of session):

Show interactive menu of recent sessions
Load selected session’s context (summary, open loops, related files)
Auto-load relevant vault context
Display where to pick up - zero “where was I?” friction

The magic: Every session creates its own documentation. And that documentation becomes the pickup point for the next session.

What Parking Does

When I type /park (or use cue words like “bedtime”, “wrapping up”, “park”), Claude:

1. Automatic Quality Check (NEW)

Before archiving anything, Claude automatically:

Checks all modified files for errors
Fixes American English → British English spellings
Updates inconsistent terminology
Fixes YAML frontmatter syntax errors
Checks for broken file paths or links

If fixes were made, shows brief report:

🔧 Auto-fixed before parking:
- Fixed 3 American English spellings in command files
- Updated terminology in CLAUDE.md (resume → pickup)

If nothing needed fixing, silent. Stays out of the way.

Why this matters: Every session gets archived “clean”. Errors caught before they compound. No manual “can you check this?” needed. Pickup sessions have correct information.

This matches my “get it right once” philosophy - the system catches errors so I don’t have to remember to check.

2. Generates Session Summary

Creates a structured summary in this format:

## Session 2 - CCO Implementation & Core Commands (9:40am-10:30am)

### Summary
[2-4 sentence narrative of what was accomplished]

### Key Insights / Decisions
[Bullet list of important realisations or choices]

### Next Steps / Open Loops
- [ ] Specific actionable item 1
- [ ] Specific actionable item 2

### Files Created
- path/to/file.md - [purpose]

### Files Updated
- path/to/file.md - [what changed]

### Pickup Context
**For next session:** [One sentence about where to pick up]
**Previous session:** [[link to previous session]]
**Project:** [[link to project hub]]

The “Next Steps / Open Loops” section is critical - explicit capture of incomplete work. This is Cal Newport’s shutdown complete ritual. Every open loop documented in a trusted system.

3. Archives to Vault

Appends summary to /mnt/nas/Files/06 Archive/Claude Sessions/YYYY-MM-DD.md

Multiple sessions per day stack chronologically in the same file. Links between sessions create temporal navigation - “what did I do yesterday?” is just clicking back through session links.

4. Updates Project Status

If work relates to an active project, updates Works in Progress.md:

Before:

### Claude Code Learning ⚠️
**Before Manny arrives (~3pm):** Create template.

After:

### Claude Code Learning ⚠️
**Status:** Core infrastructure complete. Template creation next.
**Last:** Sat 17 Jan 10:30am - Implemented 8 core commands
**Next:** Create Manny's template repo
→ [[03 Projects/Claude Code Learning]]
→ [[Session link]]

5. Confirmation

✓ Session summary saved to: 06 Archive/Claude Sessions/2026-01-17.md
✓ Open loops documented: 5 items
✓ Linked to previous session (Session 1 - Claude PKM Tools Research)
✓ Project updated: Claude Code Learning

Shutdown complete. You can rest.

To pickup: `claude` (will show recent sessions) or `/pickup`

That “Shutdown complete. You can rest.” line does something psychologically. It’s permission to let go. The system has it. Your brain can release the mental residue.

What Pickup Does

When I type /pickup (or just start Claude in my vault directory), I see:

╔════════════════════════════════════════════════════════════╗
║  Pickup Session - Recent Sessions (Last 7 Days)           ║
╠════════════════════════════════════════════════════════════╣
║  1. CCO Implementation & Core Commands - Sat 17 Jan 10:30am
║     "Core infrastructure complete, template creation next"
║     Open loops: 5 | Project: Claude Code Learning
║
║  2. Tab Management - Thu 16 Jan 7:23pm
║     "Limbic economy framework, multi-agent therapy"
║     Open loops: 3 | Project: Browser Workflow
║
║  [Enter number to pickup, 'n' for new session, 'q' to quit]
╚════════════════════════════════════════════════════════════╝

>

I select #1. Claude then:

Loads session context:
- Reads the full session summary
- Extracts the “Pickup Context” (one-sentence description of where to start)
- Shows all unchecked open loop items

Displays context:

Loading: CCO Implementation & Core Commands (Sat 17 Jan 10:30am)

Last session summary:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Implemented comprehensive Claude Code + Obsidian command infrastructure.
Created 8 core commands for session management, discovery, workflow.
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Open loops:
 [ ] Create Manny's template repository structure
 [ ] Implement bootstrap wizard for template
 [ ] Set up MCP servers (optional, not urgent)

Project: [[03 Projects/Claude Code Learning]]

Ready to continue. What's next?

Auto-loads relevant context:
- Always loads CLAUDE.md
- If project linked, reads the project hub file
- If domain-specific, reads relevant context files

Zero “where was I?” friction. I know exactly where to start. The open loops are right there. The context is loaded.

The Meta-Test

The ironic part: I tested the park system by actually parking this session.

At 10:35am, I’d been working for about an hour. Had implemented 8 commands, fixed wezterm, renamed everything to “park and pickup”. Was feeling that familiar temptation to keep going - “just implement the template for Manny now”.

But Manny doesn’t arrive until 3pm. And I wanted to test whether the system actually worked.

So I asked Claude: “Can I really close this chat and come back in 2 hours with full context?”

Claude’s response: “YES. That’s exactly what we built. Close the chat. Trust the park and pickup system.”

Fair. Let’s test it.

I typed /park.

Claude:

Auto-fixed some terminology inconsistencies
Generated session summary
Documented 5 open loops
Updated Works in Progress
Displayed “Shutdown complete. You can rest.”

I closed the terminal.

[Note: This blog post is being written in that same session, after the rename to “park and pickup” but before I actually test the pickup. The test will happen when I come back later today. I’ll update this section if the pickup fails catastrophically. If this section still says “catastrophically”, the test worked.]

Update 3:15pm: Pickup worked perfectly. Opened terminal, ran /pickup, selected this session, saw all 5 open loops, immediately knew where I was. Zero friction. The system works.

Why This Works

1. Explicit Over Implicit

The session summary forces explicit documentation. Not “I’ll remember” or “it’s in the git history somewhere”. Explicit capture: “These 3 things are incomplete.”

2. Structured Format

Meeting-minutes style. Not narrative essay. Easy to scan. The “Pickup Context” one-liner is immediately actionable.

3. Bidirectional Linking

Sessions link forward and backward through time. “What led to this decision?” - click back to previous session. “What came after?” - click forward.

4. Automatic Quality Control

The auto-lint step means archived sessions are clean. No “oops, that file has American spelling” discovered 3 sessions later. Errors caught at the boundary.

5. Cal Newport Philosophy

The “shutdown complete” ritual creates psychological closure. Your brain can let go because the system has captured everything. This is the opposite of keeping browser tabs open “to remember to do this”.

Implementation Notes

If you’re building this yourself:

Command Structure

Commands live in .claude/commands/ as markdown files with YAML frontmatter:

---
name: park
aliases: [shutdown-complete]
description: End session with shutdown complete
---

The command file is instructions to Claude about what to do when the command is invoked. Think of it as a prompt template.

Session File Location

I use /mnt/nas/Files/06 Archive/Claude Sessions/YYYY-MM-DD.md because:

My vault is on a NAS (network attached storage) mounted via CIFS
I want sessions grouped by date (easy to find “what did I do last Tuesday”)
Archive folder is for completed/reference material

Adapt the path to your structure.

Cue Word Detection

The /park command triggers on these phrases:

“bedtime”
“wrapping up”
“done for tonight”
“packing up”
“park”

This means natural language works. I don’t have to remember to type the slash command. I just say “okay, wrapping up for now” and Claude knows to park the session.

Auto-Lint Scope

The automatic quality check looks for:

American English → British English (I’m Australian, my vault uses British spelling)
Inconsistent terminology (was “parking/restore”, now “park/pickup”)
YAML syntax errors in command files
Broken file paths in links

Customize this to your own conventions. The point is: catch errors at the session boundary before they get archived.

Integration with Daily/Weekly Reviews

/park handles individual sessions (30 mins to 2 hours of work).

/daily-review aggregates sessions into daily summaries.

/weekly-synthesis looks at patterns across the week.

This creates nested temporal structure - sessions → days → weeks. Park and pickup is the foundation layer.

What I Learned Building This

The Naming Matters

Originally called this “session parking/restore”. Functional but boring.

During the session, I realized “park and pickup” is:

More action-oriented (verbs not gerunds)
Catchier and more memorable
Parallel structure (both 4-letter words starting with ‘p’)

Changed all the terminology. The better name makes the system more likely to stick.

Auto-Quality Is Non-Negotiable

I initially built /park without the auto-lint step. Just session summary generation.

Then asked Claude: “Anything to lint, refactor, proofread before I close?”

Claude found terminology inconsistencies. I realized: if I have to remember to ask that question, the system is fragile.

So I added auto-lint to the /park command itself. Now it happens automatically. One less thing to remember. One less way for errors to slip through.

Test By Using

The meta-test (actually parking this session to test the park system) revealed something important: I didn’t trust the system until I used it.

I could read the code. I could see the session summary file. But some part of my brain thought “yeah but will it actually work when I need it?”

Using it once broke that skepticism. Now I trust it.

If you build this: use it for real work within the first hour. Don’t just demo it. Actually park a session you care about and come back later. That’s when you’ll know if it works.

The Broader Pattern

This is a specific implementation of a general principle: Make implicit processes explicit and automatic.

Implicit: “I’ll remember where I left off” Explicit: Document open loops in structured format

Manual: “Let me check if there are errors” Automatic: System checks before archiving

Fragile: Depends on my memory and discipline Robust: Built into the workflow, happens whether I remember or not

The park and pickup system isn’t magic. It’s just making the handoff between sessions explicit enough that my brain can let go, and automatic enough that I don’t have to remember to do it.

What’s Next

This session management system is the foundation. With reliable park/pickup, I can build higher-level workflows:

/thinking-partner - Explore ideas through questions before solutions
/research-assistant - Vault-first deep search before web search
/weekly-synthesis - Pattern detection across sessions
/inbox-processor - NIPARAS categorisation of captured items

All of these rely on being able to park and pickup reliably. If I can’t trust that I’ll remember where a research thread was going, I won’t start deep research.

The park and pickup system removes that friction.