wrap-up

wrap-up

wrapwriteshands-on

Use this when: you're ending a session and want loose ends tied off

Problem it solves — Sessions end with loose ends — uncaptured learnings, untracked work, a dirty tree. This is the end-of-session sweep that ties them off, so the next session (or a faster model) starts clean and ahead.

Wrap up

The cost of stopping isn't the unfinished work — it's the context that evaporates: why you did it this way, what you were mid-thought on, the correction the user made an hour ago. This skill banks that before it's gone.

1 — Infer the run-set (this is the skill)

Don't run a fixed checklist — read what the session changed and how far it reached, then pick only the close-out steps that earn their place:

• git diff --stat + the conversation: what areas moved, what's half-done.
• Touched app code / fixed a gnarly bug? → find-learnings (capture the lesson).
• Clarified what Tempo is / should do? → qa-philosophy (reconcile the doc).
• Grew CLAUDE.md / rules / skills? → optimise-context (trim the new footprint).
• Surfaced unbuilt or half-wired work? → find-untracked-work (file it).
• Left clutter around — merged branches, scratch/backup files, bloated logs? → janitor.

Bias toward the capture steps (find-learnings, find-untracked-work) — those are the ones whose value is lost if you don't do them now. Skip anything the session didn't touch, and say what you skipped and why.

2 — Run them (surface-then-confirm, as each skill defines)

Each sub-skill keeps its own confirm gate — wrap-up just sequences the relevant ones. Nothing writes without your pick.

3 — The continuation brief (the deliverable)

End with a structured brief — not prose — so the next session resumes without re-deriving anything:

• Current state — what's done + committed/pushed, what's in-flight (and where it's parked), what's untouched.
• Errors & corrections — the mistakes hit this session and the right answer, prioritised (these are the highest-value lines — they stop the next session repeating them).
• Next step — the single most useful thing to do next, with the file/area to start in.
• Open threads — decisions still pending, anything waiting on the user.

Keep it skimmable. The test: could a fresh session act on it without scrolling back through this one?

Where it sits

• Not check-everything — that's a deliberate full health sweep you opt into; wrap-up is the lighter, session-scoped close-out inferred from the diff.
• It composes the same find-/qa-/optimise- skills (plus janitor for housekeeping), aimed only at what changed.