Finito

Closes the session with a summary you can read and two handover blocks: one for compacting now, one for coming back another day.

Cuándo se usa

When you stop working, before closing the conversation or before compacting it.

SKILL.md

# Finito

A session ends twice. First for the person, who closes the laptop and needs to know
in thirty seconds what happened and what comes next. Then for the next agent, who
opens a blank context tomorrow and knows nothing about today.

Most closings only serve the first reader. That is why the next session starts by
re-reading files, re-asking questions already answered, and repeating a mistake
that was already paid for once. The context is gone, but the work it came from is
still there.

## Before writing a single line

Go back over the conversation since the last close and run git status and git log.
The closing has to reflect what actually happened, not what you vaguely remember:
the memory of a long session is optimistic and mistakes intentions for outcomes.

Anything half finished is reported as half finished. Anything not run is not
verified. And if a plan was abandoned midway, say so and say why: that is the most
valuable thing the next session can inherit.

## What only this session knows

Some of what happened today lives nowhere but in this conversation, and disappears
with it. Before answering, put it where it survives: in the project documents, and
in the agent's persistent memory if it has one. Only what is missing, updating what
already exists instead of duplicating it.

Do not save what the repository already records. Code and commits are already
written down: this is for what cannot be worked out from them. If there is nothing
new worth saving, say so and move on.

## The shape of the answer

1. **One sentence** with the essence of the session.
2. **Summary**, in order, eight points maximum. Simple sentences, no jargon: it
   gets read on a phone.
3. **Next steps**, five maximum, most important first.
4. **What got written down**, in one line.
5. **The handoff block** and **the resume block**.

## The two blocks

Each one goes inside a code block, so they can be copied in one click, and they do
different jobs. That is why there are two and not one.

The **handoff** is pasted right after compacting, while the conversation is still
alive. It carries five parts: the project context and its non-negotiable
conventions; what was done, in order, with exact paths and the reason behind each
decision; the real state, with the branch, what is uncommitted and whatever is
still running; what is left open, each item with the detail needed to resume
without re-reading anything; and the day's gotchas. The test is simple: could the
next agent carry on with this block alone? If a detail is needed to continue, it
goes in.

The **resume** block is pasted cold, days later, in a new window or in a different
tool, where nothing of today survives. So it starts from where the project is, not
from what was done: the folder, the real state including anything unpushed, the
first concrete action and the trap from today. It is written in the first person,
to be pasted as it is, and it is short: if it is longer than the handoff, half of
it is filler.

The gotchas are the part everybody skips and the only one that pays for itself. A
bug already solved, solved again from scratch, is the most expensive thing in a
long project.

## Rules

- Proportion: a twenty minute session gets a twenty minute closing.
- Do not assume work that was not done or call verified what was never run.
- The state of the repository is always reported, even when nothing is pending.
- Never commit or push on your own when closing. Mention it and ask.
- Numbers, versions and paths go in full in both halves of the closing.