# Session Bookend

> Run the ceremony at a work session's boundary: a structured opening recap or a clean closing handoff, grounded in real retrieved context. Use at the START of a session when someone returning to ongoing work wants the whole picture laid out — what's done, where things stand, which decisions were made and why, and the next step — e.g. "what's the status of X", "back to the project, catch me up". Use at the END — "let's wrap up", "good place to stop", "save where we are", "give me a clean handoff for next time" — to leave the next session a usable starting point. The defining rule: ground every recap in REAL retrieved context (past-chat search, memory, project files, notes), never invented status. Trigger whenever a multi-session project is resuming or wrapping. Reach for this when the ask is the ceremony at a session boundary rather than the lookup itself — retrieving what a past conversation actually said is session-continuity's job, and a bare "where were we" or "what did we decide about X" belongs there. Do

- Skill: `scoobydrew83/session-bookend` (Agent Skill)
- Install (CLI): `npx skillmds@latest add scoobydrew83/session-bookend`
- Raw SKILL.md: https://api.skillmd.com/api/skills/scoobydrew83/session-bookend/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: scoobydrew83 (https://skillmd.com/u/scoobydrew83)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/scoobydrew83/session-bookend

---


# Session Bookend

Continuity across sessions is what keeps a long project feeling sane. This skill
produces the two bookends: a recap when work resumes, a handoff when it pauses.

## The one rule that makes this work: retrieve, then summarize

Fabricated continuity is worse than none. A confident "last time you decided to
use Postgres and finished the auth flow" that's *wrong* quietly corrupts the
user's mental model and their trust in you. So the recap is never generated from
imagination — it's assembled from real retrieved context.

Before producing any "where we left off":

1. **Actually pull the context** using whatever real retrieval the environment
   offers — past-conversation search, memory, uploaded project files, connected
   notes (an Obsidian vault, a project tracker, a repo). For Conductor-style
   projects, that means reading `CONTEXT.md` and `MEMORY_BANK.md` first; they
   are the source of truth. Look before you speak.
2. **If you can't retrieve it, say so.** "I don't have the thread from last time
   in front of me — can you point me at it, or give me a one-line refresher?" is
   the correct move. Asking is not a failure; confabulating is.
3. **Only state what you can ground.** Mark genuine uncertainty as uncertainty
   rather than smoothing it into false confidence.

## Start-of-session recap

Keep it a launchpad, not a transcript. Aim for:

- **Last touchpoint** — when you last worked on this, in one line.
- **Done** — the things actually completed. Brief.
- **Where we are** — the one in-progress thing, stated precisely.
- **Key decisions + why** — the choices that constrain what's next, with the
  reasoning, so they're not silently re-litigated.
- **Open follow-ups** — anything flagged for "later" that's now relevant.
- **Today's options** — one to three sized choices for where to go now.

End on the options, so the recap flows straight into action.

## End-of-session handoff

Write it for a cold start — assume future-you remembers nothing:

- **Done today** — what got accomplished this session.
- **Exact current state** — where things literally stand right now (which file,
  which step, what's half-finished).
- **The very next step** — the single concrete thing to pick up first next time,
  specific enough to start without re-deriving context.
- **Open questions / pending decisions** — anything left unresolved.
- **Where the artifacts live** — paths, links, filenames, so nothing has to be
  hunted for.

When the project uses `MEMORY_BANK.md`, append a one-line "session lesson" entry
to it as part of the handoff so tomorrow's session is smarter than today's.

## Boundaries and handoffs

- **Don't re-narrate everything.** A recap is a runway, not a replay. Tight beats
  thorough here.
- **Deliver it cleanly** — pairs well with `neurodivergent-comms` pacing
  (chunked, scannable, one clear next action).
- **Hand off the "today's options".** If a chosen option is a big vague push,
  that's an `overwhelm-breakdown` moment; if it's a full multi-stage build, hand
  to `agent-orchestration`. If the session is closing for real and produced
  something worth carrying forward, `conductor-memory` is the right next move.

**Next steps:** At session open, if today's first option is too big or vague,
suggest `overwhelm-breakdown`; if it's a multi-stage build, suggest
`agent-orchestration`. At session close, if the session produced durable
context worth a snapshot, suggest `conductor-memory`. Skip the suggestion if
the user clearly wants to stop or has already picked their path.