Tracks and visualizes CCPM workflow state transitions (IDEA → PLANNED → IMPLEMENTING → VERIFYING → VERIFIED → COMPLETE). Prevents invalid state transitions and suggests appropriate next actions. Auto-activates when users ask about task status, "where am I in the workflow", "what should I do next", or "can I do this now".
Tracks your CCPM workflow state (IDEA → PLANNED → IMPLEMENTING → VERIFYING → VERIFIED → COMPLETE) and prevents invalid transitions. Auto-activates when you ask about task status, "where am I", "what should I do next", or "can I do this now".
/plugin marketplace add duongdev/ccpm/plugin install ccpm@duongdev-ccpm-marketplaceThis skill is limited to using the following tools:
This skill provides real-time visibility into your CCPM workflow progress, prevents invalid state transitions, and guides you toward task completion through intelligent next action suggestions.
CCPM uses a structured 8-state workflow that progresses from concept to completion. Understanding these states helps you know exactly where you are and what to do next.
IDEA (💡)
↓
PLANNED (📋)
↓
IMPLEMENTING (🚀) ←→ BLOCKED (🚫)
↓
VERIFYING (🔍)
↓
VERIFIED (✅)
↓
COMPLETE (🎉)
CANCELLED (❌) - Terminal, can branch from any state
| State | Phase | Description | Linear Status | Progress |
|---|---|---|---|---|
| IDEA | Ideation | Initial concept, not yet planned | Backlog | 0% |
| PLANNED | Planning | Requirements gathered, plan created | Planned, Todo | 25% |
| IMPLEMENTING | Implementation | Active development in progress | In Progress, In Development | 50% |
| BLOCKED | Implementation | Cannot proceed due to blocker | Blocked | 50% |
| VERIFYING | Verification | Quality checks and review in progress | In Review, Testing | 75% |
| VERIFIED | Verification | Verified and ready to finalize | Verified, Approved | 90% |
| COMPLETE | Completion | Task finalized and closed | Done, Completed | 100% |
| CANCELLED | Cancelled | Task cancelled or abandoned | Cancelled, Archived | 0% |
When you ask "Where am I?", this skill detects your current state by checking:
Most accurate: Reads CCPM custom fields directly from Linear issue
- ccpmPhase: Current state (IDEA, PLANNED, etc.)
- ccpmLastCommand: Last CCPM command executed
- ccpmLastUpdate: Timestamp of last update
- ccpmAutoTransitions: Whether state auto-updates
If custom fields missing, infers from Linear status:
Analyzes implementation checklist progress:
Checks for uncommitted changes:
Each state has specific allowed transitions. Attempting an invalid transition will be prevented with helpful suggestions.
IDEA → PLANNED, CANCELLED
PLANNED → IMPLEMENTING, IDEA, CANCELLED
IMPLEMENTING → VERIFYING, PLANNED, BLOCKED
BLOCKED → IMPLEMENTING, CANCELLED
VERIFYING → VERIFIED, IMPLEMENTING
VERIFIED → COMPLETE, IMPLEMENTING
COMPLETE → (terminal - no transitions)
CANCELLED → (terminal - no transitions)
Each transition has a confidence score (0-100) indicating how certain the system is:
The skill prevents invalid workflows and provides helpful corrections:
❌ IDEA → IMPLEMENTING (skip planning)
Suggestion: Run /ccpm:plan first
❌ IDEA → VERIFYING (skip planning + implementation)
Suggestion: Follow workflow: IDEA → PLANNED → IMPLEMENTING → VERIFYING
❌ PLANNED → VERIFYING (skip implementation)
Suggestion: Run /ccpm:work to start implementation
❌ IMPLEMENTING → COMPLETE (skip verification)
Suggestion: Run /ccpm:verify first
❌ VERIFYING → COMPLETE (skip verified state)
Suggestion: Fix issues and re-verify, then transition to VERIFIED
❌ COMPLETE → IMPLEMENTING (reopen completed task)
Suggestion: Create new issue for follow-up work
Before allowing transitions, the skill validates pre-conditions:
Transition to PLANNED requires:
Transition to IMPLEMENTING requires:
Transition to VERIFYING requires:
Transition to VERIFIED requires:
Transition to COMPLETE requires:
Visual representation of task completion:
IDEA: [░░░░░░░░░░] 0%
PLANNED: [██░░░░░░░░] 25%
IMPLEMENTING: [████████░░] 50%
VERIFYING: [██████████░] 75%
VERIFIED: [███████████░] 90%
COMPLETE: [████████████] 100%
When checking status, you see:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎯 Workflow State
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🚀 Phase: IMPLEMENTING
📋 Status: In Progress
⚙️ Last Command: /ccpm:work
🕐 Last Update: Nov 21, 2025 2:30 PM
📍 Next Actions:
• Transition to VERIFYING
• Transition to PLANNED (re-plan)
• Transition to BLOCKED (if blocker found)
💡 Suggested: /ccpm:sync
Save progress to Linear
Confidence: 70%
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
START
↓
💡 IDEA (Plan your task)
└─→ /ccpm:plan
↓
📋 PLANNED (Ready to start)
├─→ /ccpm:work
│ ↓
🚀 IMPLEMENTING (In progress)
│ ├─→ /ccpm:sync (save progress)
│ ├─→ /ccpm:commit (commit changes)
│ ├─→ /ccpm:verify (check completion)
│ │ ↓
│ └─→ 🚫 BLOCKED (if blocker found)
│ └─→ /ccpm:verify
│ ↓ (issue resolved)
│ └─→ 🚀 IMPLEMENTING
│
└─→ /ccpm:verify (when checklist complete)
↓
🔍 VERIFYING (Quality checks)
├─→ /ccpm:verify (continue checks)
│ ↓ (all checks pass)
│ ↓
✅ VERIFIED (Ready to finalize)
└─→ /ccpm:done (create PR + complete)
↓
🎉 COMPLETE (Done!)
Based on your current state, the skill suggests the best command to execute:
Current: 💡 IDEA
Question: What should I do next?
Suggested: /ccpm:plan "Task title" <project>
Description: Create implementation plan
Confidence: 90%
Reasoning: Task needs planning before implementation
Current: 📋 PLANNED
Question: What should I do next?
Suggested: /ccpm:work
Description: Start implementation
Confidence: 90%
Reasoning: Plan is ready, begin development
Current: 🚀 IMPLEMENTING (25% complete)
Question: What should I do next?
Suggested: /ccpm:sync
Description: Save progress to Linear
Confidence: 70%
Reasoning: Document what you've done so far
Current: 🚀 IMPLEMENTING (100% complete)
Question: What should I do next?
Suggested: /ccpm:verify
Description: Run quality checks
Confidence: 85%
Reasoning: Checklist complete, verify before completion
Current: 🚫 BLOCKED
Question: What should I do next?
Suggested: /ccpm:verify
Description: Diagnose and fix blocker
Confidence: 80%
Reasoning: Address blocking issue to continue
Current: 🔍 VERIFYING
Question: What should I do next?
Suggested: /ccpm:verify
Description: Continue verification process
Confidence: 80%
Reasoning: Complete all quality checks
Current: ✅ VERIFIED
Question: What should I do next?
Suggested: /ccpm:done
Description: Finalize and create PR
Confidence: 95%
Reasoning: Verification passed, ready to complete
Current: 🎉 COMPLETE
Status: Task is finished!
No further action needed.
Understanding which commands cause which state transitions:
| Command | From State | To State | Confidence |
|---|---|---|---|
/ccpm:plan | IDEA | PLANNED | 95% |
/ccpm:plan | PLANNED | PLANNED | - (updates) |
/ccpm:work | PLANNED | IMPLEMENTING | 95% |
/ccpm:sync | IMPLEMENTING | IMPLEMENTING | - (progress update) |
/ccpm:commit | IMPLEMENTING | IMPLEMENTING | - (git commit) |
/ccpm:verify | IMPLEMENTING | VERIFYING | 85% |
/ccpm:verify | VERIFYING | VERIFIED | 85% (if checks pass) |
/ccpm:verify | VERIFYING | IMPLEMENTING | 100% (if checks fail) |
/ccpm:done | VERIFIED | COMPLETE | 95% |
/ccpm:verify | BLOCKED | IMPLEMENTING | 85% |
These commands automatically update your workflow state in Linear:
plan, planning:create, planning:plan, planning:updatework, implementation:start, implementation:syncverify, verification:check, verification:verifydone, complete:finalizeFor edge cases, you can manually override state:
Task(linear-operations): `
operation: update_issue_state
params:
issue_id: "PSN-29"
phase: "IMPLEMENTING"
reason: "Manual override due to external blocker"
context:
command: "workflow-state-tracking:manual-override"
`
When a blocker is detected, workflow transitions to BLOCKED:
Blockers automatically detected by:
• Pre-condition validation failures
• Security audit failures
• Code review failures marked as blocking
• External dependency issues
• Permission/environment issues
When BLOCKED:
1. Suggested command: /ccpm:verify
2. Diagnose the specific issue
3. Take corrective action
4. Re-run verification
5. Transition back to IMPLEMENTING
Example:
🚫 BLOCKED: Security audit detected vulnerabilities
Blocker Details:
• SQL injection risk in user input handler
• Missing CSRF token validation
• Hardcoded API key in config
Suggestions:
1. Fix: Parameterize database queries
2. Fix: Add CSRF token middleware
3. Fix: Move API key to environment variable
Status: /ccpm:verify
You can ask the skill for workflow information:
Returns current state with progress indicators and suggestions
Shows valid transitions from current state
Checks if command is allowed in current state
Shows any blockers preventing progression
Displays checklist completion percentage and phase progress
Visualizes the complete state machine and your position
Step 1: Check where you are
User: "Where am I in the workflow?"
Skill: "You're in PLANNING state. Your plan was created 2 hours ago."
Step 2: Get next suggestion
User: "What should I do next?"
Skill: "Suggested: /ccpm:work (90% confidence)"
Step 3: Start implementation
User: "/ccpm:work"
System: Transitions PLANNING → IMPLEMENTING
Step 4: Work on task
User: [Does actual implementation]
Step 5: Periodic sync
User: "/ccpm:sync"
System: Saves progress (stays in IMPLEMENTING)
Step 6: Check progress
User: "How much is done?"
Skill: "Checklist 85% complete. Nearly ready to verify."
Step 7: Finalize and verify
User: "/ccpm:verify"
System: Transitions IMPLEMENTING → VERIFYING
Step 8: All checks pass
System: Transitions VERIFYING → VERIFIED
Step 9: Finalize
User: "/ccpm:done"
System: Transitions VERIFIED → COMPLETE
If displayed state doesn't match reality:
1. Check Linear custom fields: ccpmPhase field
2. Fall back to Linear status inference
3. Analyze checklist completion
4. Check git status for uncommitted changes
If still misaligned:
/ccpm:work PSN-29 (detailed state diagnostics)
1. Identify blocker: /ccpm:work
2. Diagnose issue: /ccpm:verify
3. Fix root cause
4. Re-verify: /ccpm:verify
5. Return to IMPLEMENTING: Automatic on successful verification
If transitioned too early (e.g., PLANNING → VERIFYING):
1. Use /ccpm:plan to re-plan if needed
2. Or transition back to IMPLEMENTING: /ccpm:work
3. Complete actual implementation
4. Then proceed with verification
1. Check Linear write permissions
2. Verify custom fields exist: linear custom fields setup
3. Check Jira sync if using Jira integration
4. Review Linear comments for transition history
/ccpm:work <issue-id>
/ccpm:work <issue-id>
/ccpm:sync <project>
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.