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).
# 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:
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:
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
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