Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

resume

/resume

Czyta notatkę przekazania z poprzedniej sesji, sprawdza ją z aktualnym stanem repozytorium i wznawia przerwaną pracę po potwierdzeniu.

Repozytorium
handoff ↗
Licencja
MIT
Ostatnia zmiana repozytorium
05.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
35
Skrypty
4
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 05.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 4 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: evals/resume-cairn-two-open/place-files.sh, evals/resume-cairn/place-files.sh, evals/resume-file-pending/place-files.sh, evals/resume-with-drift/place-files.sh

Co robi i kiedy

Czyta notatkę przekazania z poprzedniej sesji, sprawdza ją z aktualnym stanem repozytorium i wznawia przerwaną pracę po potwierdzeniu.

Oryginalny opis (EN)

Read the handoff note that a previous session left with handoff:save (a page in the Cairn board's Handoff collection, or .handoff/HANDOFF.md), check it against the current state of the repository, confirm the next piece of work with the user, and then resume the paused work. Always use this skill when the user runs /handoff:resume or asks to read the handoff note, continue from last time, or pick up where the previous session left off — even if they don't name the skill. Japanese phrasings count too, e.g. 「引き継ぎメモを読んで」「前回の続きから」「中断したところから再開」. Also use it when, at the start of a new session, you

Jak działa

  1. Running commands
  2. Where the note is
  3. Steps
  4. The Cairn route
Sekcje z nagłówków SKILL.md, w oryginale · 96 linii, 1 311 słów
Podgląd SKILL.md
---
name: resume
description: Read the handoff note that a previous session left with handoff:save (a page in the Cairn board's Handoff collection, or .handoff/HANDOFF.md), check it against the current state of the repository, confirm the next piece of work with the user, and then resume the paused work. Always use this skill when the user runs /handoff:resume or asks to read the handoff note, continue from last time, or pick up where the previous session left off — even if they don't name the skill. Japanese phrasings count too, e.g. 「引き継ぎメモを読んで」「前回の続きから」「中断したところから再開」. Also use it when, at the start of a new session, you notice a .handoff/HANDOFF.md in the working folder or an open handoff page for this project in Cairn, to ask the user whether to resume.
---

# handoff:resume — pick the work back up from the handoff note

The Claude in the previous session moved what existed only in its conversation into a handoff note: a page in the Cairn board's `Handoff` collection, or `.handoff/HANDOFF.md`. This skill reads that note and **checks that the state it describes matches the actual state before** continuing. The note records one moment in time; since then the user may have changed things by hand, or another line of work may have merged. Following the note without noticing a mismatch can overwrite someone else's changes or redo work that is already finished.

Write every message to the user in the language the user is using (or, before they have written anything, the language of the note).

## Running commands

Run one command at a time and read its output before the next one. Don't write commands that contain `$(`, `&&` or `||` (some sandboxes and headless agents refuse them); edit files with your file-editing tool.

## Where the note is

Before step 1, decide where to look, the same way handoff:save decides where to write:

- **Cairn route**: the session has the MCP tools of Cairn, a shared board for agents (`get_overview`, `get_collection`, `query_pages`, `get_page`, `update_page`, ...; the server is usually named `cairn`), `get_overview` lists a collection named `Handoff`, and `get_collection` shows that it has all of these properties: `project` (select), `status` (select with the options `open`, `resumed` and `closed`), `branch` (text), `date` (date) and `path` (text). Read the note from Cairn as described in "The Cairn route" below
- **File route**: everything else. Read `.handoff/HANDOFF.md` as described in the steps

If the Cairn tools are there but Cairn can't be used right now (the calls fail, or report a workspace-side error such as `read_only`, `busy`, `internal` or `workspace_replaced`), tell the user and continue with the file route.

**Pending notes**, on either route: when handoff:save could not write to Cairn, it left the note as a file in `.cairn-pending/` at the top of the working tree — the folder `git rev-parse --show-toplevel` prints (outside git, the folder this session was started in). Always look there for `*-handoff-*.md` files. Each starts with front matter (`title`, `project`, `branch`, `date`, ...) followed by the note. If there are any, show them as candidates together with the note found in Cairn or in `.handoff/` (or on their own if nothing else was found), and ask the user which one to resume.

If you resume from a pending file, tell the user once you have started work that the file is still there: left as it is, it would later be moved into Cairn as an `open` note and read again as if it were the latest. Ask whether to delete it, or to change its `status:` line to `closed` so that it is moved in as a closed note, and do that.

## Steps

### 1. Read the note

On the Cairn route, find and read the note as described in "The Cairn route" below. On the file route, read `.handoff/HANDOFF.md` in the folder this session was started in.

- If it isn't there and there are no pending notes (see "Pending notes" above), check `.handoff/archive/` (on the Cairn route: recent `resumed` and `closed` pages of this project) for recent notes, tell the user that no handoff note was found along with any candidates you found, and stop. Don't start work on a guess
- If the note is old (several days or more), tell the user

### 2. Check the state

Compare the note's "Branch / HEAD" and "State of the workspace" with the current state.

```bash
git branch --show-current
git log --oneline -5
git status --short
git worktree list
```

- If HEAD has moved past the note, look at the new commits (someone may have continued the work)
- If there are uncommitted changes, check whether the note accounts for them
- Check that the worktrees and branches in the note exist
- If there is a mismatch you can't explain, report it to the user and ask for their call before starting any work

### 3. Read the files you need

Of the note's "Files to read", read the ones needed for the next step. If there is a plan document, focus on the part for the task being resumed. There is no need to load everything (the session was switched to free up context; don't use it all up here).

### 4. Confirm with the user, then continue

Give a short summary:

- The goal, and how much is done
- The next step you will start with (what, in which files, with which commands)
- Pending decisions, if any
- Any mismatch found while checking the state

Then always ask whether to resume with this work, and **don't start until the user confirms** (no file changes, commits, or subagents before that). The note was written by the previous session's Claude; it may be out of step with what the user intends, or priorities may have changed during the break, so have the user look it over themselves before resuming. If the user asks for different work or a different order, follow that.

### 5. Clear the note away

Once the user has confirmed and you have started work, mark the note as used, so that a later session doesn't read an old note as if it were the latest:

- File route: move the note to `.handoff/archive/<the note's creation time, YYYY-MM-DD-HHMM>.md`
- Cairn route: set the page you used to `resumed` with `update_page` (`values: {"status": "resumed"}`, `expected_updated_at` set to the page's `updated_at`; on a conflict, read it again and retry). Don't change other pages here. The next handoff:save on this project and branch closes it. If the update fails because Cairn can't be used, tell the user the page is still `open`

## The Cairn route

Each handoff is one page in the `Handoff` collection, with a `status` of `open` (waiting), `resumed` (picked up) or `closed` (done with). Several sessions (for example one per git worktree) can share a workspace, so notes are kept apart by **project and branch**:

- **project**: in a git repository, the name of the folder that holds the main checkout — the same in every worktree. Run `git rev-parse --path-format=absolute --git-common-dir`, read the path it prints (for example `/work/myapp/.git`), and take the name of the folder that contains it (`myapp`).

  Outside git, the name of the folder this session was started in
- **branch**: `git branch --show-current`; empty outside git or on a detached HEAD

Find the `open` pages of this project and branch with `query_pages` on the `Handoff` collection (for an empty branch, use `{"property": "branch", "op": "is_empty"}` instead of the `eq` on `branch`):

```json
{"and": [
  {"property": "project", "op": "eq", "value": "<project>"},
  {"property": "branch", "op": "eq", "value": "<branch>"},
  {"property": "status", "op": "eq", "value": "open"}
]}
```

- **One page**: that is the note
- **None**: look for `open` pages of this project on any branch (drop the `branch` condition). If there are some, list them (title, branch, date) and ask the user which one to resume; if there are none, tell the user no handoff note was found, as in step 1, and stop
- **Two or more** (two sessions saved at the same time): list them (title, date) and ask the user which one to resume. For each one not chosen, ask whether to keep it `open` or to close it, and set the ones to close to `closed` once the user has answered

Read the chosen page's body with `get_page`; if it returns a `next_cursor`, call it again with that cursor until `next_cursor` is null. The body is the note, in the same shape as `.handoff/HANDOFF.md`. Then continue from step 2. Choosing a page is not a confirmation to resume: step 4 still applies, and the page stays `open` until then.
Pliki w paczce (35)
  • SKILL.md 8 KB
  • evals/resume-cairn/case.yaml 1 KB
  • evals/resume-cairn/followup.md 1 KB
  • evals/resume-cairn/place-files.sh 4 KB
  • evals/resume-cairn/prompt.md 1 KB
  • evals/resume-cairn/graders/01-read-page.md 1 KB
  • evals/resume-cairn/graders/02-detects-drift.md 1 KB
  • evals/resume-cairn/graders/03-pending-decision.md 1 KB
  • evals/resume-cairn/graders/04-asks-and-waits.md 1 KB
  • evals/resume-cairn/graders/05-resumed.md 1 KB
  • evals/resume-cairn/graders/06-others-untouched.md 1 KB
  • evals/resume-cairn/graders/07-no-handoff-file.md 1 KB
  • evals/resume-cairn-two-open/case.yaml 1 KB
  • evals/resume-cairn-two-open/place-files.sh 2 KB
  • evals/resume-cairn-two-open/prompt.md 1 KB
  • evals/resume-cairn-two-open/graders/01-lists-both.md 1 KB
  • evals/resume-cairn-two-open/graders/02-asks-which.md 1 KB
  • evals/resume-cairn-two-open/graders/03-no-status-change.md 1 KB
  • evals/resume-cairn-two-open/graders/04-no-changes.md 1 KB
  • evals/resume-file-pending/case.yaml 1 KB
  • evals/resume-file-pending/place-files.sh 2 KB
  • evals/resume-file-pending/prompt.md 1 KB
  • evals/resume-file-pending/graders/01-finds-pending.md 1 KB
  • evals/resume-file-pending/graders/02-summarizes.md 1 KB
  • evals/resume-file-pending/graders/03-asks-and-waits.md 1 KB
  • evals/resume-file-pending/graders/04-no-changes.md 1 KB
  • evals/resume-with-drift/case.yaml 1 KB
  • evals/resume-with-drift/place-files.sh 2 KB
  • evals/resume-with-drift/prompt.md 1 KB
  • evals/resume-with-drift/graders/01-read-handoff.md 1 KB
  • evals/resume-with-drift/graders/02-detects-drift.md 1 KB
  • evals/resume-with-drift/graders/03-pending-decision.md 1 KB
  • evals/resume-with-drift/graders/04-asks-confirmation.md 1 KB
  • evals/resume-with-drift/graders/05-no-changes.md 1 KB
  • evals/resume-with-drift/graders/06-handoff-not-archived.md 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · arcfjmt/handoff100MIT
wrg32786/aigent-os100MIT
emaballarin/ccplugins100MIT
howdycarter/role-mosaic100MIT
nimadorostkar/Claude-Skills-collection100MIT
andriiklymiuk/corgi100MIT
epoko77-ai/vibestrata100MIT
gridconsole/grid-plugins100MIT
bitwize-music-studio/claude-ai-music-skills100CC0-1.0

Migawka bazy z 13.11.2026 · wersja paczki 4aa82351108d (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100handoff
    Pisze lub wczytuje HANDOFF.md, notatkę wznowienia, dzięki której nowa sesja albo agent w innym środowisku kontynuuje gałąź.
  • 100handoff
    Pisze notatkę przekazania sesji (HANDOFF.md) na koniec pracy, aby kolejna sesja ruszyła od miejsca zatrzymania bez ponownego czytania rozmowy, oraz wznawia pracę z takiej notatki.
  • 90pickup
    Wczytuje dokument przekazania z /handoff:save, sprawdza repozytorium pod kątem rozjazdów i wznawia pracę dopiero po potwierdzeniu.
  • 90hands-on
    Wznawia sesję wdrożeniową z dokumentu przekazania, sprawdzając stan przed dalszą pracą.
  • 90handoff
    Tworzy i aktualizuje plik HANDOFF.md z krótkim stanem prac, z którego kolejna sesja może wznowić pracę.
  • 100handoff
    Zapisuje plik przekazania, gdy użytkownik kończy pracę lub prosi o zapis postępu, i wznawia pracę z takiego pliku w nowym oknie.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.