# 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". - Skill: `matteocervelli/progress` (Agent Skill) - Install (CLI): `npx skillmds@latest add matteocervelli/progress` - Raw SKILL.md: https://api.skillmd.com/api/skills/matteocervelli/progress/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: matteocervelli (https://skillmd.com/u/matteocervelli) - Updated: 2026-09-09 - Page: https://skillmd.com/skills/matteocervelli/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: ( | clean) - Working tree: - Release: + unreleased commits - Open PRs: <"None" or "#N title"> ## Last Session ### Where you left off (last 3 days) - (): → Open issue: # — - <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