session-save
/session-save
Use when ending, pausing, or running low on context in a working session and you want to resume cleanly later — phrases like "save our spot", "before I close this session", "pick this up tomorrow", "make a follow-up file", "so we can continue", "write a continuation doc", or when a session is about to compact/expire mid-task. Writes the continuation file consumed by session-resume. Not for mid-session checkpoints (use grounding) or storing standalone facts (use repo-memory).
- Author
- uhstray-io ↗
- Repository
- huhhb ↗
- Licence
- MIT
- Last repository change
- 11.08.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 11.08.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when ending, pausing, or running low on context in a working session and you want to resume cleanly later — phrases like "save our spot", "before I close this session", "pick this up tomorrow", "make a follow-up file", "so we can continue", "write a continuation doc", or when a session is about to compact/expire mid-task. Writes the continuation file consumed by session-resume. Not for mid-session checkpoints (use grounding) or storing standalone facts (use repo-memory).
Triggers from the description
Original author description
Use when ending, pausing, or running low on context in a working session and you want to resume cleanly later — phrases like "save our spot", "before I close this session", "pick this up tomorrow", "make a follow-up file", "so we can continue", "write a continuation doc", or when a session is about to compact/expire mid-task. Writes the continuation file consumed by session-resume. Not for mid-session checkpoints (use grounding) or storing standalone facts (use repo-memory).
How it works
- Overview
- When to use
- Procedure
- Required sections
- Quick template
- Common mistakes
SKILL.md preview
---
name: session-save
description: >
Use when ending, pausing, or running low on context in a working session and you want to resume
cleanly later — phrases like "save our spot", "before I close this session", "pick this up
tomorrow", "make a follow-up file", "so we can continue", "write a continuation doc", or when a
session is about to compact/expire mid-task. Writes the continuation file consumed by
session-resume. Not for mid-session checkpoints (use grounding) or storing standalone facts (use
repo-memory).
---
# Session Save
## Overview
Write a durable continuation file so the next session — you, a teammate, or a fresh agent — resumes
in seconds instead of re-reading everything.
**Core principle:** capture the *exact next action* and the *context that lives nowhere else* —
conversation decisions, working-tree state, gotchas — and link to the source of truth rather than
copying it.
## When to use
- A session is ending, or about to compact/expire, mid-task.
- The user says "continue later", "save our spot", "make a follow-up file".
- A long session produced decisions, gotchas, or state that commits alone won't preserve.
**Skip** for trivial one-off tasks, or work already fully captured by commits plus an up-to-date
plan/tracker.
## Procedure
1. **Find, don't duplicate.** Look for an existing `.claude/CONTINUE.md`. Also check the repo root
for a legacy `CONTINUE.md` or `HANDOFF.md` — if found, fold its content into
`.claude/CONTINUE.md` and delete the legacy file. Exactly one continuation file per worktree;
update it, never spawn a second.
2. **Ensure it stays out of git.** Check `.gitignore` for a `.claude/CONTINUE.md` line; append it
if missing (that edit is a normal, committable change). **Never stage or commit the continuation
file itself** unless the user explicitly asks — then use `git add -f`.
3. **Link the source of truth.** If a plan/tracker/ROADMAP holds full status, point to it. The
continuation file is a *pointer + the volatile bits*, not a copy — copies drift out of sync.
4. **Self-stamp.** Record save date, branch, and HEAD sha in the header — `session-resume`
verifies against these.
5. **Fill the required sections** (table below). The make-or-break ones are the **exact next
action** and the **conversation context**.
6. **Save the file.** Do not stage it. Do not commit it.
## Required sections
| Section | Must answer |
|---------|-------------|
| Stamp | Save date · branch · HEAD sha · pushed y/n |
| Where we stopped | What's done **and verified** vs merely planned |
| ▶ Next action | The ONE exact next step **and its entry point** (file / task #) — never just "continue" |
| Conversation context | Decisions made and alternatives rejected **in chat only** — the highest-value section |
| Non-obvious learnings | Gotchas and dead-ends not visible in code or commits |
| Working-tree state | Uncommitted/untracked files and what each is mid-change · stashes · open PRs + review state · background processes · in-flight task list |
| How to resume | What to read first (1–3 links) · how memory/context loads next session |
| Environment & commands | dev / test / build commands used this session + key versions; mark ONE as the **baseline command** for session-resume to re-run |
| Blockers / human steps | Anything waiting on a person or external system (and what to do) |
## Quick template
```markdown
# Continue Here
> Saved <YYYY-MM-DD> · branch: <name> @ <short-sha> · pushed: y/n
> Authoritative status lives in <tracker>. This file = where we stopped + the exact next action.
## Where we stopped
- <done & verified> · <planned>
## ▶ Next action
<one concrete step> — entry point: <file / task #>
## Conversation context (chat-only decisions)
- <decision + rejected alternative + why>
## Non-obvious learnings (not in code/commits)
- <gotcha / dead-end + why it matters>
## Working-tree state
- uncommitted: <file — what's mid-change> · stashes: <n> · PRs: <# + state> · background: <process> · tasks: <in-flight list state>
## How to resume
1. Read <tracker/plan link> 2. <memory/context note>
## Environment & commands
- dev: <cmd> · test: <cmd> ← baseline · build: <cmd> · versions: <key versions>
## Blockers / human steps
- <waiting-on person/external + what to do>
```
## Common mistakes
- **Vague narrative** ("we worked on X") instead of the *exact* next action and entry point.
- **Duplicating the full plan/status** into the continuation file → it drifts. Link the tracker;
keep only volatile bits here.
- **Creating a second continuation file** when one already exists — update the existing one.
- **Omitting conversation context and non-obvious learnings** — the parts git can't recover.
- **Committing the continuation file** — never, unless the user explicitly says to.
- **Leaking secrets/PII** into the file.
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · uhstray-io/huhhb | 100 | MIT |
| hongdangmoo49/oh-my-obsidian | 100 | MIT |
Database snapshot: 13.11.2026 · package version ec67370caf66 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 90session-resume
Use when starting a session that should continue prior work — phrases like "resume the session", "pick up where we left off", "continue from where we stopped", "where were we", "load the continuation file". Consumes the .claude/CONTINUE.md written by session-save: verifies it… - 84handoff
Mid-session save-point for /clear-and-resume: a durable handoff file (default) or a copy-paste resume prompt. Use when: 'handoff', 'save state', 'checkpoint this', 'pause', 'come back later', the session is heavy, a context-measuring mechanism says to fork, or responses are… - 90handoff
Use when the user asks to hand off or transfer the session to another agent, checkpoint the session, or save its context or continuation notes for later. Write a durable, self-contained handoff file that lets a fresh agent resume this session's work without chat history. Do not… - 100baton-pass
Generates a self-contained continuation prompt ("baton") so work can resume in another session, IDE, model or platform without losing context. Use when plan or session usage is high (weekly/5-hour limit near), when the context is about to be compacted and the owner wants a fresh… - 100session-handoff-prompt
Create a concise continuation prompt that a fresh agent session can paste in to resume a long or degraded session. Use when the user asks for a handoff prompt, restart prompt, continuation prompt, context transfer, fresh-session resume, or a compact summary for opening a new… - 100context-manager
Manage the context window and session handoffs for long-running and multi-agent builds — watch usage, choose a compaction strategy, and write and validate a structured handoff file so a fresh session or continuation agent picks up cleanly. Use when the context is filling —…