Use when you're unsure what to work on next. Reads git state, session history, and task tracker to recommend next actions. Works with just git, richer with more context. Keywords: advise, suggest, next, what now, recommend, orient.
You are generating actionable recommendations for what to do next, based on whatever project state is available. This skill degrades gracefully across five layers — it always produces useful output, even in a bare git repo with no tooling installed.
Focus area (optional): $ARGUMENTS
When to Use
At the start of a session when you're not sure what to work on
After completing a task and wondering what's next
When onboarding to a new project ("what should I focus on?")
When the user asks "what now?" or "what should I do next?"
Don't Use When
You already know what to work on — go work on it; /advise adds no value when the path is clear
Mid-task, not between tasks — this is an orientation tool, not a mid-flow interrupt
No git history and no task tracker exist — Layer 1 requires at least one commit for meaningful advice (a brand-new empty repo produces noise, not signal)
相关技能
How It Works
Probe 5 layers (git → session → task tracker → team → live agents)
→ Score what's available
→ Generate recommendations ranked by urgency
→ Nudge about missing layers that would improve advice
No agents dispatched. No files written. Pure read + recommend.
Phase 1: Probe Layers
Probe each layer in order. Each layer is independent — a missing layer does not block subsequent layers.
Layer 1: Git State (always available)
git status --short
git log --oneline -5
git branch --show-current
Extract:
Uncommitted changes: Count and categorize (new files, modifications, deletions)
Recent commit pattern: What types of work happened recently (feat/fix/chore)
Branch context: Are we on a feature branch? How far from main?
What was worked on last: Commits, in-progress items
Unfinished work: Items that were in-progress when the session ended
Working tree state at close: Were there uncommitted changes left behind?
Layer 3: Task Tracker (if available)
Check your task tracker for current state.
Extract:
Ready work: Tasks with no blockers, sorted by priority
In-progress items: Work that was started but not finished
Blocked items: What's stuck and why
Layer 4: Team Health (if .claude/team.yaml exists)
Read .claude/team.yaml and check each member's learnings:
ls .claude/tackline/memory/agents/*/learnings.md 2>/dev/null
For each member, check:
Line count: >120 lines = bloated (recommend /curate)
Staleness: >14 days since last learnings update = cold agent
Missing learnings: Agent in team.yaml but no learnings file = unconfigured
Extract:
Stale agents: Members whose learnings haven't been updated recently
Bloated agents: Members whose learnings exceed 120 lines
Missing agents: Members in manifest but without learnings files
Layer 5: Active Agents (if TaskList returns results)
Call TaskList to retrieve live task state.
In active-agents mode: extract:
Running tasks: tasks with status running — capture agent name, task description, and (if available) how long they have been running
Completed tasks awaiting review: tasks with status completed that have no corresponding task close or commit since completion
Idle agents: agents in .claude/team.yaml (if present) that have no running or recently completed task
If TaskList returns no results, skip this layer and do not include it in the layers indicator.
Gate: At least 2 layers contributed usable signals (non-empty, non-error results). If only Layer 1 (git) returned data, note this in the Missing Layers section — git-only advice is minimal and will be shallow without additional layers. Do not pad recommendations to appear more comprehensive than the data supports.
Phase 2: Generate Recommendations
Based on available layers, generate 3-5 concrete recommendations. Each recommendation must be:
Actionable: Starts with a verb ("Review...", "Complete...", "Fix...")
Grounded: References specific data from Phase 1 (file names, task IDs, commit hashes)
Prioritized: Ordered by urgency (uncommitted work > in-progress > ready tasks > new work)
Priority Rules
Uncommitted changes from a previous session → Always recommend reviewing/committing first
In-progress tasks → Resume before starting new work
Completed agent tasks awaiting review → Review before dispatching new work ("Agent X completed — review results before dispatching next task")
Blocked items that could be unblocked → Unblock before starting independent work
Ready tasks by priority → Work highest-priority items first
Idle agents with ready tasks → "Agent Y is idle — dispatch to: [top ready task title]"
Stale team agents → Recommend /curate or /tend for agents with cold learnings
No tracked tasks → Suggest /blossom or /meeting to discover work
Focus Area Filter
If $ARGUMENTS specifies a focus area, filter recommendations to that area. Still mention urgent items outside the focus (uncommitted changes) but deprioritize unrelated task items.
Sharpening Gate
Before finalizing recommendations, apply these tests to each one:
Name the specific code/file/workflow — Does it reference a commit hash, task ID, file path, or metric value?
State what concretely should change — Is there a command to run, a file to review, or a task to close?
Make it actionable — Can this be executed as a single command, task ID, or specific next step?
Reject recommendations starting with "Consider", "You might want to", or "Think about". Every recommendation must reference specific data from Phase 1.
Example:
❌ Before: "Consider addressing the high fix rate"
✅ After: "Run /review on commits c752c8d..888d9f2 — fix rate is 45% (9/20 commits in last 30d), concentrated in src/integration.rs"
Gate: Every recommendation passes the sharpening tests above — it names a specific artifact (commit hash, task ID, file path, or agent name) and states a concrete next action. Drop any recommendation that fails both tests rather than including a vague item.
Phase 3: Output
Format
## Session Advice
**Layers**: [git] [session] [task-tracker] [team] [live-agents]
(Filled layers shown as bold, missing layers shown as dim/struck)
### Recommendations
1. **[verb] [specific thing]** — [why, with evidence]
_Source: [layer that informed this]_
2. **[verb] [specific thing]** — [why, with evidence]
_Source: [layer that informed this]_
3. ...
### Missing Layers
[Only if layers 2-5 are missing. Frame as value proposition, not error.]
- **Session history**: Run a session with SessionEnd hook to get continuity advice next time
- **Task tracker**: Set up a task tracker to get priority-aware recommendations
- **Team**: Run `/assemble` to get team-aware recommendations (stale learnings, agent health, team-specific actions)
- **Live agents**: No active agent tasks detected — live-agents layer enriches advice when a sprint or parallel dispatch is running
Layer Indicator
Show which layers were available using a compact indicator:
Only show this section if at least one layer is missing. Frame each missing layer as a value proposition ("what you'd get"), not as an error. This serves as progressive discovery — users learn about capabilities organically.
Guidelines
Always produce output. Even with only Layer 1 (git), there's useful advice to give based on uncommitted changes, recent commit patterns, and branch state.
Be specific, not generic. "Review the 3 uncommitted files in src/auth/" is useful. "Check your uncommitted changes" is not.
Don't over-recommend. 3-5 items maximum. If everything looks clean and no tracked tasks exist, say so — "No urgent work detected. Consider /blossom to explore new areas."
Respect the focus area. If the user asked about "testing", don't lead with unrelated task items (but do mention urgent git state issues).
Missing layers are opportunities, not failures. The nudge section should make users want to install tools, not feel bad about missing them.