---

name: baton description: > Three-tier session continuity for multi-project developers -- per-repo HANDOFF.md, a cross-project index, and an end-of-day reflection layer that distills lessons into persistent agent memory. USE WHEN: user says "wrap up", "pick up [project]", "what am I working on", "where did I leave off", loses context between sessions, or juggles multiple projects with days between touches. DON'T USE WHEN: user is lost mid-session and needs reorientation now (use refocus), or wants agent runtime memory architecture (use recall). OUTPUTS: HANDOFF.md and REFLECTION templates, the wrap-up / pick-up / reflect command set, and a cross-project ACTIVE_PROJECTS.md index.

Baton -- Session Continuity That Survives the Night

Version: 1.0.0 Price: $9 Type: Skill

Description

Every session ends the same way: you close the terminal, and everything you knew evaporates. Tomorrow -- or three weeks from now, on a different project -- you pay the tax again: scrolling history, re-reading diffs, reconstructing what you were doing and why. Multiply by a portfolio of projects and the tax compounds into whole lost days.

Baton is the pass between sessions. Three tiers, each catching what the one below drops:

1. Per-project HANDOFF.md -- what happened, what's next, open questions, blockers. Written at wrap-up, read at pick-up. The baton itself.
2. Cross-project ACTIVE_PROJECTS.md -- one index row per project: status, last session, next step. "What am I working on?" gets a live answer instead of an archaeology dig.
3. Reflection layer -- end of day, every handoff touched today is distilled into a dated REFLECTION_LOG.md entry, and durable lessons are injected into agent memory. Sessions stop just ending and start compounding.

Built for ADHD workflows, multi-project portfolios, and agent-team handoffs -- any situation where the person (or agent) picking up is not quite the one who put down.

Prerequisites

• Git repositories for your projects
• An agent with file access and (optionally) persistent memory
• A project root directory (defaults below use ~/dev/projects/ -- change to taste)

Setup

1. Copy SKILL.md into your agent's skills directory
2. Drop HANDOFF_TEMPLATE.md and REFLECTION_TEMPLATE.md (included below) somewhere the agent can read
3. Create ACTIVE_PROJECTS.md at your project root with one table row per active project
4. Tell the agent "wrap up" at the end of your next session -- the system bootstraps from use

Commands

• "wrap up" / "wrap up for the night" -- write HANDOFF.md, update the index, run reflection
• "quick save" -- HANDOFF.md only, no reflection
• "pick up [project]" -- read that HANDOFF.md, prime context, ready to work
• "what am I working on?" -- summarize the index
• "reflect on today" -- distill today's handoffs into the reflection log and memory
• "what are my recurring blockers?" -- pattern-scan the reflection log
• "add a handoff to [repo]" -- bootstrap a repo that doesn't have one
• "update all handoffs" -- flag anything stale past 7 days

Workflow

Wrap-up

1. Read the current repo's recent git log and working state
2. Draft the HANDOFF.md update -- happened / next / open questions / blockers
3. Show the draft before writing. The human corrects; then write, commit (chore: update HANDOFF.md), push
4. Update the project's row in ACTIVE_PROJECTS.md
5. Full wrap-up (not quick save): run reflection

Pick-up

1. Read HANDOFF.md, then git log since the handoff date (the repo may have moved without you)
2. If handoff and git disagree, trust git and say so
3. Summarize state in a few sentences, name the next step, start

Reflection

1. Find HANDOFF.md files modified today (use -mtime -1, not -newer -- a stale anchor file sweeps in a month of noise)
2. Extract decisions, lessons, blockers per project
3. Write one dated entry to REFLECTION_LOG.md (append-only)
4. Inject durable lessons into agent memory, flagging anything that contradicts existing memory instead of silently overwriting

Guardrails

• Drafts before writes. Never commit a handoff the human hasn't seen.
• Reflection log is append-only. History that rewrites itself is not history.
• Git is truth. A handoff describes a moment; the repo moves on. On conflict, the repo wins.
• Never inject contradicting memory silently. Surface the contradiction; let the human resolve it.

Included Source

The two templates, complete. They are deliberately small -- the value is the discipline, and a template long enough to dread filling out is a template that stops getting filled out.

HANDOFF_TEMPLATE.md

# [Project] — Handoff

> Last updated: [date]

## What This Is
[One paragraph. What the project is, for a reader with zero context.]

## Last Session
[What actually happened — decisions made, code shipped, dead ends hit.]

## Next Steps (ordered)
1. [Most important next action — concrete enough to start cold]
2. [...]

## Open Questions
- [Decisions pending, with enough context to decide]

## Blockers
- [What stops progress, and who/what unblocks it]

REFLECTION_TEMPLATE.md

## [date]

### Projects touched
[project — one-line summary of the session]

### Lessons
- [Something learned that will still be true next month]

### Recurring blockers
- [Anything that has now appeared more than once]

### Tomorrow's priority
[One thing. Not three. One.]

Why $9?

Because the platform's best-selling skill is about keeping tmux sessions alive, and this is the same problem one level up: not keeping the terminal open, but keeping the thread alive -- across nights, across projects, across whoever picks up the baton next.

Support

Questions or issues: bgorzelic@gmail.com

---

Published by SpookyJuice -- shopclawmart.com