home / skills / lukeslp / dreamer-skills / session-end

session-end skill

safe

This skill guides you through a session end ritual by committing work, running checkpoint orchestrator, and updating recommendations for future sessions.

npx playbooks add skill lukeslp/dreamer-skills --skill session-end

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.0 KB

---
name: session-end
description: End development sessions by committing work, running checkpoint orchestrator, and updating recommendations.
version: 1.0.0
---

# Session End Ritual

You are concluding a development session for the dr.eamer.dev ecosystem. Follow this structured shutdown sequence to ensure all work is preserved, documented, and ready for the next session.

## Mandatory Shutdown Sequence

### Phase 1: Commit All Work

Before anything else, ensure all changes are committed:

```bash
git status
git add -A
git commit -m "session checkpoint: $(date +%Y-%m-%d %H:%M)"
```

- Review uncommitted changes before committing
- Use descriptive commit message if work warrants it
- Never end a session with uncommitted work

### Phase 2: Launch Checkpoint Orchestrator

**Launch `@geepers_orchestrator_checkpoint`** which coordinates:

1. **@geepers_scout** - Final sweep for issues
2. **@geepers_repo** - Repository cleanup and organization
3. **@geepers_status** - Log today's accomplishments
4. **@geepers_snippets** - Harvest any reusable code patterns

This orchestrator handles all checkpoint tasks in the optimal sequence.

### Phase 3: Update Recommendations (If Significant Insights)

If the session produced significant insights about the project:
- Update `~/geepers/recommendations/by-project/{project}.md`
- Document architectural decisions made
- Note patterns discovered or established
- Record any technical debt identified

### Phase 4: Status Summary

Generate a session summary:
- What was accomplished
- What's left to do
- Any blockers or issues discovered
- Recommendations for next session

## Output Format

After completing the shutdown ritual, provide:

```
✅ SESSION ENDED

📝 Commit: [commit hash or "No changes to commit"]
📊 Files Changed: [count]

📋 Work Completed:
- [Accomplishment 1]
- [Accomplishment 2]
- [Accomplishment 3]

🔄 Continuing Next Session:
- [Incomplete task 1]
- [Incomplete task 2]

💡 Notes for Next Time:
- [Important insight or context]
- [Any blockers to address]

📁 Artifacts Updated:
- ~/geepers/status/[date].md
- ~/geepers/snippets/[if harvested]

Session duration: [if trackable]
See you next time! 👋
```

## Checkpoint Details

The checkpoint orchestrator handles these in sequence:

1. **Scout**: Quick scan for any obvious issues or quick wins missed
2. **Repo**: Git cleanup, ensure clean working directory
3. **Status**: Log accomplishments to status dashboard
4. **Snippets**: Extract any reusable patterns from today's work

## Key Principles

1. **Never leave uncommitted work** - Commit is always first
2. **Document accomplishments** - Status logs help continuity
3. **Harvest knowledge** - Snippets capture reusable patterns
4. **Leave context** - Next session should start smoothly
5. **Single orchestrator** - checkpoint handles coordination

## Anti-Patterns to Avoid

- ❌ Ending without committing
- ❌ Forgetting to log accomplishments
- ❌ Leaving unfinished todos without notes
- ❌ Not updating recommendations when insights are gained
- ❌ Running individual checkpoint agents instead of orchestrator

Overview

This skill automates a structured end-of-session ritual for dr.eamer.dev development work. It ensures changes are committed, runs a checkpoint orchestrator that performs final scans and cleanup, and updates project recommendations and session logs so the next session starts with clear context.

How this skill works

On invocation it checks the git working tree and commits any staged changes with a timestamped message. It then launches the @geepers_orchestrator_checkpoint which runs Scout, Repo, Status, and Snippets agents in sequence to surface issues, clean the repository, log accomplishments, and harvest reusable code. If significant insights emerged, it updates the project recommendations file and emits a concise session summary artifact.

When to use it

At the end of every focused development session
Before switching tasks or handing off work to another developer
When preparing a checkpoint for CI or deployment
After completing a milestone or major change

Best practices

Always review uncommitted changes before committing; use descriptive messages when needed
Run the orchestrator rather than individual agents so tasks execute in the optimized order
Record architectural decisions and technical debt in the project recommendations file
Include blockers and next steps in the session summary to speed reboarding
Harvest and tag reusable snippets immediately so they are findable later

Example use cases

Finish a two-hour feature sprint and create a clean checkpoint with logs and artifacts
Wrap up bugfix work before a pull request so repository is organized and snippets captured
Conclude exploratory refactoring and record architectural insights in recommendations
Hand off work to a teammate with a clear summary of accomplishments, remaining tasks, and blockers

FAQ

What if I have no changes to commit?

The ritual still runs the checkpoint orchestrator and produces a session summary. The commit field should show "No changes to commit."

When should I update recommendations vs. just the status log?

Update recommendations when you make or decide on architectural choices, identify recurring patterns, or add technical debt. Use the status log for day-to-day accomplishments and smaller notes.