Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

checkpoint

/checkpoint

Zapisuje punkt kontrolny pracy: robi commit WIP w git i aktualizuje zgłoszenie Linear komentarzem z postępem.

Repozytorium
claude ↗
Licencja
MIT
Ostatnia zmiana repozytorium
26.10.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
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

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

Licencja

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

Co robi i kiedy

Zapisuje punkt kontrolny pracy: robi commit WIP w git i aktualizuje zgłoszenie Linear komentarzem z postępem.

Wyzwalacze z opisu

checkpointsave progresswip commit
Oryginalny opis (EN)

Save progress checkpoint — git commit WIP and update Linear issue with progress comment. Use when the user says 'checkpoint', 'save progress', 'wip commit', or invokes /checkpoint.

Jak działa

  1. Arguments
  2. Workflow
  3. Key Differences from /finish
  4. Error Handling
Sekcje z nagłówków SKILL.md, w oryginale · 196 linii, 1 281 słów
Podgląd SKILL.md
---
name: checkpoint
description: Save progress checkpoint — git commit WIP and update Linear issue with progress comment. Use when the user says 'checkpoint', 'save progress', 'wip commit', or invokes /checkpoint.
---

# Checkpoint

Lightweight mid-task save: commit work-in-progress to git and post a progress update to the Linear issue.

## Arguments

- Issue identifier (e.g., `PL-12`) — optional, auto-detected from branch name or latest commit
- `no push` / `don't push` / `skip push` — optional, skips the git push step (commit still happens)

Examples: `/checkpoint`, `/checkpoint PL-12`, `/checkpoint no push`, `/checkpoint PL-12 no push`

## Workflow

### Preflight: Exit Plan Mode If Active

If the session is in plan mode, call `ExitPlanMode` first with a one-line plan ("Checkpoint the current branch: commit WIP and post progress to <ISSUE-ID or 'the current branch's issue'>" — inline a user-typed ID only when it matches `^[A-Z]+-[0-9]+$`, uppercased) — Bash and Write are blocked in plan mode, so Step 1 cannot run before it. Do not call it when plan mode is off: it raises a spurious approval prompt; when the indicator is ambiguous, try Step 1 and return here only if `detect-issue-id.sh` is blocked by plan mode. If the user rejects the plan, stop with:

```text
IN-PROGRESS: <ISSUE-ID or "current branch"> — user rejected /checkpoint at the plan-mode preflight. No commit, no Linear update.
```

If the tool itself errors, stop with the same tag naming the error's first line. Nothing has changed in either case, which is why the tag is IN-PROGRESS; do not retry or continue to Step 1.

### Step 1: Identify the Issue

```bash
~/.claude/scripts/detect-issue-id.sh [--input <USER-SUPPLIED-ID>]
```

The script tries `--input` → current branch → latest commit subject, in that order. Pass `--input` only when the user typed an explicit ID (e.g., `/checkpoint PL-12`). On exit 1, ask the user for the identifier explicitly.

### Step 2: Branch Safety

Verify we're NOT on `main` or `master`. Checkpoint is for feature branches only — refuse and explain if on a protected branch.

### Step 3: Verify Changes Exist

```bash
git status
```

If there are no staged or unstaged changes (working tree is clean), warn the user that there's nothing to checkpoint and exit. A checkpoint without code changes isn't a checkpoint.

### Step 4: Get Issue Details

```bash
linear-cli issues get PL-42
```

Read the description. Note:

- Title (for commit message)
- Requirement checkboxes (`- [ ]` items)

### Step 5: Update Completed Checkboxes

If any `- [ ]` checkboxes have been completed, update them now.

```bash
# Get current description as JSON
linear-cli issues get PL-42 --output json
```

For each `- [ ]` checkbox in the description:

- **If completed**: replace with `- [x]`
- **If not completed**: leave as `- [ ]`

If any checkboxes changed, update the description:

1. Use the `Write` tool to save the full updated description to `tmp/linear-description-<issue-id-lowercased>.md` (e.g., `tmp/linear-description-pl-42.md`)
2. Run:

```bash
~/.claude/scripts/linear-post.sh description PL-42 tmp/linear-description-pl-42.md
```

**Important**: Preserve the entire description — only change `- [ ]` to `- [x]` for completed items. Do not rewrite or reformat.

Skip this step entirely if no checkboxes changed.

### Step 6: Check Status (non-blocking)

```bash
pnpm check
```

Record whether checks pass or fail. Do NOT gate on this — it's WIP. If checks fail, note which checks failed for the Linear comment. Continue regardless.

### Step 7: Git Commit & Push

**Invoking `/checkpoint` IS the commit/push grant** for this one WIP checkpoint — see
[Git Standards](../../standards/git.md) § Named exceptions. It is bounded to the named issue's
change set, staged by name; the push half is suppressible with `no push`. It grants nothing beyond
this invocation.

Stage relevant changed files by name (never `git add .` or `git add -A`).

Commit message format: `checkpoint: <brief summary> [<ISSUE-ID>]`

- Imperative mood, lowercase after prefix
- Include issue key in brackets for traceability
- Example: `checkpoint: add auth middleware and route guards [PL-42]`

```bash
git add <specific-files>
git commit -m "checkpoint: <summary> [PL-42]"
```

Then push to remote (unless `no push` was requested):

```bash
git push
```

If the user requested **no push**, skip and inform: "Skipping push as requested. Push manually when ready: `git push`"

### Step 8: Post Linear Comment

Write a checkpoint comment summarizing progress. Structure:

```markdown
## Checkpoint

### Completed
- [bullet points of what's done so far]

### In Progress
- [what's partially done]

### Remaining
- [what's left to do]

### Check Status
✅ All checks pass / ⚠️ Failures: [list failing checks]

### Commit
`<short-sha>` on branch `<branch-name>`
```

Omit empty sections. Keep it concise — this is a status update, not a report.

1. Use the `Write` tool to save the comment to `tmp/linear-checkpoint-<issue-id-lowercased>.md` (e.g., `tmp/linear-checkpoint-pl-42.md`).
2. Run:

```bash
~/.claude/scripts/linear-post.sh comment <ISSUE-ID> tmp/linear-checkpoint-<issue-id-lowercased>.md
```

### Step 9: Tagged Final Line

After Step 8 posts the Linear comment, emit the tagged final line per `standards/lifecycle-tags.md` as the last LLM-authored output. `/checkpoint` always ends with `IN-PROGRESS:` since the issue stays in `In Progress` and work is expected to resume.

**Every `<...>` token in the templates below is a substitution site** — replace each with the resolved value before emitting; never write a literal `<placeholder>` to chat. `<ISSUE-ID>` is uppercase (e.g., `PL-42`); `<issue-id-lowercased>` is lowercase (e.g., `pl-42`) and MUST match the filename Step 8 wrote.

**Inspect the exit code from Step 8's `linear-post.sh` invocation** to decide which branch fires below. If the bash exit code was non-zero, take the "Step 8 failed" branch even if the prose output looks partially normal — non-zero is the signal that matters.

**Step 8 succeeded** (`linear-post.sh` exited 0):

```text
IN-PROGRESS: <ISSUE-ID> — <one-line progress summary: e.g., "3 of 5 requirement checkboxes complete; paused mid-implementation.">
```

The summary should match what was just posted to Linear (so the agents-list and Linear stay in sync). For multi-section comments, distill the most recent `### Completed` count or the most-significant in-progress item — one line, not a paraphrase of the whole body.

**Step 8 failed** (`linear-post.sh` exited non-zero — auth dropped, network blip, Linear outage): do NOT silently emit a tag claiming success. Surface the staging-file path so the user can recover, then emit:

```text
IN-PROGRESS: <ISSUE-ID> — <one-line progress summary>. WARNING: Linear comment NOT posted (linear-post.sh failed; see error above). Staging file preserved at tmp/linear-checkpoint-<issue-id-lowercased>.md — re-post manually with: ~/.claude/scripts/linear-post.sh comment <ISSUE-ID> tmp/linear-checkpoint-<issue-id-lowercased>.md
```

The agents-list still shows `IN-PROGRESS:` (work IS in progress), but the inline WARNING makes the de-sync visible so the user doesn't assume Linear was updated.

Do not emit any trailing prose after the tagged line.

## Key Differences from /finish

| Aspect | /checkpoint | /finish |
|--------|-------------|---------|
| `pnpm check` | Non-blocking (report only) | Hard gate |
| Issue state | No change (stays In Progress) | Moves to Ready For Release |
| Checkboxes | Update completed ones | Update all completed ones |
| Git push | Default on, `no push` flag | Default off, `push` flag (`pr` implies it) |
| Linear comment | Progress snapshot | Completion summary |
| Scope | Quick save | Full completion workflow |

## Error Handling

- **On main/master**: Refuse — "Checkpoint is for feature branches. Switch to a feature branch first."
- **No changes**: Warn — "Nothing to checkpoint. Working tree is clean." Exit.
- **No issue found**: Ask the user for the issue identifier.
- **`linear-cli` not authenticated**: Prompt `linear-cli auth oauth`.
- **Push fails**: Warn but don't fail — the commit is saved locally. User can push later.
- **Linear post fails (Step 8 `linear-post.sh` exits non-zero)**: Surface the error to the user, preserve the staging file (`tmp/linear-checkpoint-<issue-id-lowercased>.md`), and proceed to Step 9 — which inspects the exit code and emits `IN-PROGRESS:` with an inline WARNING that Linear was NOT updated and a recovery command. Do not silently emit a clean `IN-PROGRESS:` (the agents-list would then claim success while Linear has no record of the checkpoint).

Wersje

RepozytoriumWynikLicencja
Ta strona · alienfast/claude100MIT
lvlup-sw/exarchos100Apache-2.0
automateyournetwork/netclaw100Apache-2.0
dtiger1889-ops/claude-harness-toolbox100MIT
agentcrew-academy/harness-starter-kit100MIT
Sellyew/Workbuddy-workflow100MIT
spencerneutron/Synapse100MIT
Shweta-Mishra-ai/tokenmizer100MIT
htlin222/dotfiles100MIT

Migawka bazy z 13.11.2026 · wersja paczki b8169ab37b50 (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

  • 100context-update
    Zapisuje krótki punkt kontrolny w trakcie sesji i aktualizuje bieżący stan, gdy zmienił się priorytet lub otwarty wątek, na wyraźną prośbę użytkownika.
  • 90git-checkpoint
    Tworzy lokalne commity z już gotowej pracy, rozdzielając zmiany na osobne, przeglądalne punkty bez wysyłania na zdalne repozytorium.
  • 100checkpoint-writer
    Zapisuje stan bieżącej fazy pipeline'u na dysk i tworzy commit odzyskiwania na koniec każdej fazy implementacji, przed compactem lub sesją, aby wznowić po przerwaniu.
  • 100build-next
    Buduje kolejny element gry według planu, uruchamia ją, sprawdza działanie i zapisuje punkt kontrolny.
  • 100git-commit
    Zatwierdza przygotowane zmiany commitem z komunikatem w formacie conventional commit.
  • 100git-commit
    Zatwierdza przygotowane zmiany commitem z komunikatem w formacie conventional commit.

Uwagi i zgłoszenia

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