Skip to content
Skills Library
Personal productivity · Planning

progress

/progress

On-demand situational awareness — fresh git/PR snapshot plus continuation, distilled into one concrete "next action" suggestion. Use mid-session when you've lost track, after a compaction, or starting a new work block. Trigger on "where was I", "what's next", "progress", "what should I do now", "/progress".

Repository
llms ↗
Licence
MIT
Last repository change
21.05.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.05.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

On-demand situational awareness — fresh git/PR snapshot plus continuation, distilled into one concrete "next action" suggestion. Use mid-session when you've lost track, after a compaction, or starting a new work block. Trigger on "where was I", "what's next", "progress", "what should I do now", "/progress".

Triggers from the description

next actionwhere was Iwhatprogresswhat should I do now
Original author description

On-demand situational awareness — fresh git/PR snapshot plus continuation, distilled into one concrete "next action" suggestion. Use mid-session when you've lost track, after a compaction, or starting a new work block. Trigger on "where was I", "what's next", "progress", "what should I do now", "/progress".

How it works

  1. Purpose
  2. Usage
  3. Workflow
  4. Output Format
  5. Related Skills
Original SKILL.md headings · 163 lines, 1,095 words
SKILL.md preview
---
name: progress
description: On-demand situational awareness — fresh git/PR snapshot plus continuation, distilled into one concrete "next action" suggestion. Use mid-session when you've lost track, after a compaction, or starting a new work block. Trigger on "where was I", "what's next", "progress", "what should I do now", "/progress".
---

# Progress Skill

## Purpose

Fills the routing gap that SessionStart leaves open. SessionStart injects data; `/progress` interprets it and tells you what to do next.

Use mid-session when you've lost track, after a context compaction, or at the start of a new work block.

**What it does NOT do:** Re-fetch GitHub issues, CHANGELOG, or codebase map — those are already in session context from SessionStart. Running `/progress` will not flood your context window.

## Usage

```
/progress              # current repo only (default)
/progress --all        # cross-repo: show recent work from all projects
/progress --no-memory  # skip memory recall entirely (fastest, git-only)
```

No subcommands at v1. One command, one compact output.

## Workflow

### Step 0 — Memory context (skip if `--no-memory`)

Run the memory recall command with a hard 10-second timeout. If the command fails, times out, or returns empty or invalid JSON (`[]`, whitespace, non-JSON output), silently skip this step and proceed to Step 1 — this enrichment must never block the rest of `/progress`.

**Default (`/progress`):** scope to current repo only via `--project`.
**With `--all`:** query all repos (omit `--project`, use `--deep --since`).

```bash
# Detect current repo name (same logic as memory injection hook)
CURRENT_REPO=$(git remote get-url origin 2>/dev/null | sed 's/.*\///' | sed 's/\.git$//')
# Fallback: directory name
CURRENT_REPO=${CURRENT_REPO:-$(basename "$PWD")}

# Compute ISO date for 3 days ago (macOS: date -v-3d, Linux: date -d '3 days ago')
SINCE_DATE=$(date -v-3d +%Y-%m-%d 2>/dev/null || date -d '3 days ago' +%Y-%m-%d 2>/dev/null || echo "")

# Default: scope to current repo
# With --all: cross-repo (drop --project, add --deep --since)
if [[ "$FLAGS" == *"--all"* ]]; then
  RECALL_FLAGS="--deep ${SINCE_DATE:+--since "$SINCE_DATE"}"
else
  RECALL_FLAGS="--project "$CURRENT_REPO""
fi

timeout 10 uv run --project ~/.claude/skills/memory/recall \
  python ~/.claude/skills/memory/recall/scripts/memory_recall.py \
  "recent work" $RECALL_FLAGS --compact --limit 5 2>/dev/null
```

Parse the JSONL output (one JSON object per line). Each line has: `project`, `branch`, `date`, `summary`. Compact mode pre-filters short/empty summaries, so results are already clean.

**Filter out empty results** — discard any entry where `summary` is empty or where `project` is an empty string.

**Group by project** — keep only the most recent session per project (highest `date`). Cap at 3 entries total.

**Extract issue references** from each `summary` — look for bare `#N` and `owner/repo#N` patterns.

**Cross-reference** extracted issues. For each session with a non-empty `branch`, the branch name often encodes the project context. For the repo identity, run `git remote get-url origin` in the current directory and parse `owner/repo` from the URL. Bare `#N` references belong to that repo.

For each unique `owner/repo` identified (at most 3 across all sessions), fetch open issues:

```bash
gh issue view N -R owner/repo --json number,title,state,labels \
  --jq 'select(.state=="OPEN") | {number,title,labels}' 2>/dev/null
```

Use `labels` to extract priority. Priority inference: look for a label matching `P0`, `P1`, `P2`, `P3` (case-insensitive). If the title starts with `[P0]`/`[P1]`/`[P2]`/`[P3]` (following the project's naming convention), extract it from there. If no priority signal found, treat as P3.

Store these results — they feed the "Where you left off" section and the routing engine in Step 4.

### Step 1 — Fresh git snapshot

Run these commands to get current (not session-start) state:

```bash
git status --short
git log --oneline -3
git branch --show-current

# Release awareness
LAST_TAG=$(git describe --tags --abbrev=0 --match "v*" 2>/dev/null)
UNRELEASED_COUNT=$(git log --no-merges --oneline "${LAST_TAG:-$(git rev-list --max-parents=0 HEAD)}..HEAD" 2>/dev/null | wc -l)
RELEASE_TAG_AT_HEAD=$(git tag --points-at HEAD | grep '^v' | head -1)
```

### Step 2 — PR check

```bash
gh pr list --state open --json number,title,headRefName 2>/dev/null || echo "Not a GitHub repo or gh not configured"
```

### Step 3 — Continuation check

Read `.claude/memory/local/continuation.md` if it exists. Extract the first meaningful line (skip blank lines and the auto-header). This is fresher than what was auto-loaded at session start.

### Step 4 — Routing engine

Analyze the collected state and output the **Situation Report** (see format below) followed by one `→ Next Action` recommendation.

Apply these rules in priority order:

| State                                                         | Suggestion                                                            |
| ------------------------------------------------------------- | --------------------------------------------------------------------- |
| Staged files in git                                           | `/pre-commit` — staged changes ready for validation                   |
| Unstaged changes on `feature/*` or `fix/*`                    | `/review changes` — review before staging                             |
| On `feature/*`/`fix/*` with commits, no open PR               | `/pr-creator` — branch has unreleased work                            |
| Open PR exists                                                | `/review pr --pr N` then `/pr-merge` when ready                       |
| Continuation mentions specific in-progress task               | Resume that task (name it explicitly)                                 |
| Memory (Step 0) surfaces P0/P1 open issue from recent session | `/implementation --issue N` — resume highest-priority cross-repo work |
| HEAD tagged `v*` (just released)                              | Post-release: `/release verify tags`, close milestone, plan next      |
| On `main`, clean, >10 unreleased commits                      | Release candidate — run `/release plan` to scope a version            |
| On `main` with uncommitted changes                            | Unusual state — clarify before proceeding                             |
| Clean state, no continuation, no open PRs                     | `/story plan` or `/release plan` — what's next on the backlog?        |

If multiple rules match, apply the highest-priority one only.

## Output Format

Keep the total output under 25 lines.

```
## Situation
- Branch: <branch-name> (<N commits ahead of main> | clean)
- Working tree: <staged/unstaged summary, or "clean">
- Release: <last-tag> + <N> unreleased commits
- Open PRs: <"None" or "#N title">

## Last Session
<one-line summary from continuation.md, or "No continuation found">

### Where you left off (last 3 days)
- <project> (<YYYY-MM-DD>): <one-line summary of what was happening>
  → Open issue: <repo>#<N> — <title>
- <project> (<YYYY-MM-DD>): <one-line summary>
  → No open issues referenced

Suggested next: <repo>#<N> (<priority>, last touched N days ago)

## → Next Action
/<skill> — <one-sentence rationale>
```

**"Where you left off" rules:**

- Show at most 3 project entries, most recent first by `started_at`.
- Omit the entire section (including the header) if Step 0 produced no results.
- Each entry is exactly 2 lines: summary line + issue status line.
- Truncate the one-line summary to ~100 characters if needed.
- "Suggested next" picks the highest-priority open issue across all entries. Priority order: P0 > P1 > P2 > P3. Ties broken by recency (most recently active project wins). Omit if no open issues were found.

## Related Skills

- `/memory recall` — underlying retrieval engine powering Step 0
- `/pre-commit` — full validation before commit
- `/review changes` — companion review of uncommitted changes
- `/pr-creator` — create PR from current branch
- `/pr-merge` — merge an open PR
- `/story plan` — plan next sprint from backlog
- `/release plan` — scope next version release

Versions

RepositoryScoreLicence
This page · matteocervelli/llms100MIT
Embassy-of-the-Free-Mind/sourcelibrary-v2100AGPL-3.0
builderio/agent-native100MIT
olehsov/gcp-certification-coach100MIT
M-reza-kd/lead-flow-plugin100MIT
yarikleto/claude-teacher-plugin100MIT
avsm/ocaml-claude-marketplace100ISC
maludb/learn-claude100MIT
caidanw/skills86MIT

Identical content appears in 1 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 4ce135d59c37 (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

  • 100ph
    Prepare session handoff for continuation in a new conversation. Use when 'prepare handoff', 'save progress', 'session handoff', 'I need to stop', 'prepare for next session', 'hand off', 'write handoff', or when the user wants to pause mid-implementation and resume later in a fresh context window.
  • 100ph
    Prepare session handoff for continuation in a new conversation. Use when 'prepare handoff', 'save progress', 'session handoff', 'I need to stop', 'prepare for next session', 'hand off', 'write handoff', or when the user wants to pause mid-implementation and resume later in a fresh context window.
  • 95project-progress
    Track long project work in PROGRESS.md so the context window only holds the current task. Sets the file up, adds items to its Next list, starts the next item with a plan, parks side ideas instead of chasing them, and checkpoints a finished item before a /clear. Use whenever the…
  • 90situational-awareness
    Use when the user is back on a branch or PR and says \"bring me up to speed\" or \"I'm back\": where it left off, repo state, what reviews ask.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.