/skill-task-management-v2

name: skill-task-management
disable-model-invocation: true
aliases:
  - task-management
  - todo-orchestration
description: "Manage tasks with Claude Code native tools — use to track TODOs, delegate work, and monitor progress"
trigger: |
  EXPLICITLY USE when user requests task management:
  - "add to the todo's" or "add this to todos"
  - "resume tasks" or "continue tasks" or "pick up where we left off"
  - "save progress" or "save progress for Claude to pick up"
  - "save progress to pickup later" or "checkpoint this"
  - "proceed to next steps" or "continue to next"

  DO NOT activate for:
  - Git operations (use skill-finish-branch)
  - Simple todo list viewing
  - Task completion with push (use skill-finish-branch)

Task Management & Orchestration (v7.23.0+)

Overview

Systematic task orchestration for multi-step work, progress checkpointing, and seamless task resumption across sessions.

**Core principle:** Track → Checkpoint → Resume → Complete.

**v7.23.0 Migration:** This skill now uses native Claude Code Task tools:

• `TaskCreate` - Create new tasks
• `TaskUpdate` - Update task status/details
• `TaskList` - View all tasks
• `TaskGet` - Get specific task details

**Benefits:**

• ✅ Tasks show in native Claude Code UI
• ✅ Better progress tracking and visualization
• ✅ Consistent with Claude Code conventions
• ✅ No dependency on external TodoWrite tool

---

When to Use

**Use this skill when user wants to:**

• Add items to the todo list
• Save current progress for later continuation
• Resume previously saved work
• Checkpoint progress in long-running tasks
• Proceed to next steps in a workflow
• Continue from where they left off

**Do NOT use for:**

• Creating git commits (use skill-finish-branch)
• Simple todo list queries ("what's on my list?")
• Task completion that involves pushing code

---

Core Capabilities

1. Adding Tasks to Todo List

When user says "add to the todo's" or similar:

**What would you like to add to the todo list?**

I'll help you capture this task. Please provide:
- Task description (what needs to be done)
- Any dependencies or prerequisites
- Priority (if applicable)

**After getting details, use TaskCreate to add:**

TaskCreate({
  subject: "[Brief task description]",
  description: "[Detailed description including dependencies and context]",
  activeForm: "Working on [task description]"
})

**Then confirm to user:**

✅ Task created: [Task description]

View all tasks with TaskList or use /tasks command.

---

2. Saving Progress / Checkpointing

When user says "save progress" or "checkpoint this":

Step 1: Assess Current State

# Check git status
git status

# Check current branch
git branch --show-current

# Check uncommitted work
git diff --stat

Step 2: Create Progress Checkpoint

**Option A: Git-based checkpoint (if git repo)**

# Create a work-in-progress commit
git add .
git commit -m "WIP: [description of current state]

Progress checkpoint - work in progress
Not ready for review or merge

Current state:
- [What's completed]
- [What's in progress]
- [What's next]

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>"

**Option B: Task-based checkpoint (preferred for tracking)**

Create checkpoint task with detailed state:

TaskCreate({
  subject: "Checkpoint: [Brief description]",
  description: `
📍 CHECKPOINT: ${new Date().toISOString()}

Completed:
✓ [Task 1]
✓ [Task 2]

In Progress:
⚙️ [Current task with details]

Next Steps:
- [ ] [Next task 1]
- [ ] [Next task 2]
- [ ] [Next task 3]

Context:
- Branch: ${branchName}
- Last commit: ${lastCommit}
- Files changed: ${filesChanged}
  `,
  activeForm: "Checkpoint saved"
})

Step 3: Update Existing Tasks

Mark completed tasks as done:

// For each completed task
TaskUpdate({
  taskId: "[task-id]",
  status: "completed"
})

Mark current task as in_progress:

TaskUpdate({
  taskId: "[current-task-id]",
  status: "in_progress"
})

Step 4: Provide Resume Instructions

✅ Progress saved!

To resume this work:
1. Run: git checkout [branch-name]
2. View tasks: TaskList
3. Say: "resume tasks" or "pick up where we left off"

Current state:
- Branch: [branch-name]
- Tasks: [X completed, Y in progress, Z pending]
- Last checkpoint: [timestamp]

---

3. Resuming Tasks

When user says "resume tasks" or "pick up where we left off":

Step 1: Load Task State

// Get all tasks
const tasks = TaskList()

// Filter by status
const completed = tasks.filter(t => t.status === 'completed')
const inProgress = tasks.filter(t => t.status === 'in_progress')
const pending = tasks.filter(t => t.status === 'pending')

// Find checkpoint task (if exists)
const checkpoint = tasks.find(t => t.subject.startsWith('Checkpoint:'))

Step 2: Check Git State

# Check for WIP commits
git log --oneline -10 | grep WIP

# Check current branch
git branch --show-current

# Check git status
git status

Step 3: Present Current State

📋 **Resuming from last checkpoint**

**Branch:** [branch-name]
**Last checkpoint:** [timestamp from WIP commit or checkpoint task]

**Completed:** (${completed.length} tasks)
${completed.map(t => `✓ ${t.subject}`).join('\n')}

**In Progress:** (${inProgress.length} tasks)
${inProgress.map(t => `⚙️ ${t.subject}`).join('\n')}

**Next Steps:** (${pending.length} tasks)
${pending.map((t, i) => `${i + 1}. [ ] ${t.subject}`).join('\n')}

**Would you like me to:**
1. Continue with the next task?
2. Modify the plan?
3. See more details about current state?

Step 4: Execute Based on Choice

• If "continue with next task" → Get first pending task, mark as in_progress, and begin work:

  const nextTask = pending[0]
  TaskUpdate({ taskId: nextTask.id, status: 'in_progress' })
  // Begin working on nextTask

• If "modify the plan" → Use AskUserQuestion to