---
description: Quick task status overview - optimized for speed
argument-hint: '[task-id]'
allowed-tools: mcp__task_master_ai__*, Bash(git branch)
---

# Task Status Overview

**Optimized for speed - provides quick snapshot of project status in under 2 seconds.**

See [~/.claude/guides/agents.task-master.md](../../guides/agents.task-master.md) for Task Master integration details.

## Usage

```bash
# Show overview of all tasks
/task
/task:status

# Show specific task status with action menu
/task:status 1.2
/task:status 5
```

## Implementation

### Check for Task ID Argument

**If task ID is provided ($ARGUMENTS is not empty):**

- Jump to [Specific Task View](#specific-task-view)

**Otherwise:**

- Continue with [Overview Mode](#overview-mode)

---

## Overview Mode

### 1. Get Current Context

```bash
# Get current branch for tag context
BRANCH=$(git branch --show-current)
TICKET_ID=$(echo "$BRANCH" | grep -oE '[A-Z]+-[0-9]+' | head -1)
```

### 2. Get Task Lists

```javascript
// Get all tasks efficiently (skip subtasks for speed)
const allTasks = mcp__task_master_ai__get_tasks({
  projectRoot: process.cwd(),
  withSubtasks: false,
});

// Get current tag
const tags = mcp__task_master_ai__list_tags({
  projectRoot: process.cwd(),
});
```

### 3. Calculate Statistics

```javascript
// Group tasks by status
const tasksByStatus = {
  done: allTasks.filter((t) => t.status === 'done'),
  inProgress: allTasks.filter((t) => t.status === 'in-progress'),
  blocked: allTasks.filter((t) => t.status === 'blocked'),
  pending: allTasks.filter((t) => t.status === 'pending'),
};

// Calculate progress
const totalTasks = allTasks.length;
const completedTasks = tasksByStatus.done.length;
const progressPercentage = Math.round((completedTasks / totalTasks) * 100);
```

### 4. Find Next Recommended Task

**Simple recommendation logic (fast):**

```javascript
// 1. First, try to continue in-progress tasks
if (tasksByStatus.inProgress.length > 0) {
  recommendedTask = tasksByStatus.inProgress[0];
  rationale = 'Continue current work before starting new tasks';
}

// 2. Otherwise, find next unblocked pending task
else {
  const unblockedTasks = tasksByStatus.pending.filter((task) => {
    // Check if all dependencies are met
    if (!task.dependencies || task.dependencies.length === 0) return true;

    return task.dependencies.every((depId) => {
      const depTask = allTasks.find((t) => t.id === depId);
      return depTask && depTask.status === 'done';
    });
  });

  // Sort by priority and sequence
  unblockedTasks.sort((a, b) => {
    const priorityOrder = { high: 3, medium: 2, low: 1 };
    const aPriority = priorityOrder[a.priority || 'medium'];
    const bPriority = priorityOrder[b.priority || 'medium'];

    if (aPriority !== bPriority) return bPriority - aPriority;

    // Secondary sort by ID (sequence)
    return a.id.localeCompare(b.id, undefined, { numeric: true });
  });

  recommendedTask = unblockedTasks[0];
  rationale = 'Follows project sequence with no blockers';
}
```

### 5. Display Status Template

```markdown
# Task Master Status

**Branch:** ${BRANCH}
**Tag:** ${currentTag || TICKET_ID || 'default'}

## =� Progress Overview

**Tasks by Status:**

-  Done: ${tasksByStatus.done.length} tasks
- <� In Progress: ${tasksByStatus.inProgress.length} tasks
- � Blocked: ${tasksByStatus.blocked.length} tasks
- � Pending: ${tasksByStatus.pending.length} tasks

**Total:** ${completedTasks}/${totalTasks} tasks complete (${progressPercentage}%)

${tasksByStatus.inProgress.length > 0 ? `

## <� Current Work

### In Progress (${tasksByStatus.inProgress.length})

${tasksByStatus.inProgress.map((task, i) => {
  return `${i + 1}. [${task.id}] ${task.title}`;
}).join('\n')}
` : ''}

${tasksByStatus.blocked.length > 0 ? `

### Blocked (${tasksByStatus.blocked.length})

${tasksByStatus.blocked.map((task, i) => {
  const deps = task.dependencies?.map(d => `[${d}]`).join(', ') || 'Unknown';
  return `${i + 1}. [${task.id}] ${task.title} - waiting on ${deps}`;
}).join('\n')}
` : ''}

## � Next Available Tasks

${recommendedTask ? `

### Recommended

**[${recommendedTask.id}] ${recommendedTask.title}**

- Priority: ${recommendedTask.priority || 'medium'}
- Dependencies: ${recommendedTask.dependencies?.length > 0 ? ' All met (' + recommendedTask.dependencies.map(d => `[${d}]`).join(', ') + ')' : 'None'}

**Rationale:** ${rationale}
` : 'No available tasks'}

### Quick Wins (<1 hour)

${unblockedTasks.filter(t => t.estimatedHours && t.estimatedHours < 1).slice(0, 3).map(t =>
  `- [${t.id}] ${t.title}`
).join('\n') || 'None identified'}

### High Priority

${unblockedTasks.filter(t => t.priority === 'high').slice(0, 3).map(t =>
  `- [${t.id}] ${t.title}`
).join('\n') || 'None'}

## =� Recommendation

${recommendedTask ? `
**Next Task:** [${recommendedTask.id}] ${recommendedTask.title}

**To start with full context and validation:**
\`\`\`
/task:next
\`\`\`

**Or start immediately:**
\`\`\`
/task:show ${recommendedTask.id}
\`\`\`
`:`
<� **All tasks are complete!**
`}

---

_Tip: Use \`/task:next\` for intelligent task selection with full context and validation._
```

---

## Specific Task View

**When task ID is provided as argument:**

### 1. Get Task Details

```javascript
// Get the specific task with all details
const task = mcp__task_master_ai__get_task({
  projectRoot: process.cwd(),
  id: $ARGUMENTS, // e.g., "1.2" or "5"
});
```

### 2. Display Task Status

```markdown
# Task Status: [${task.id}] ${task.title}

**Status:** ${task.status}
**Priority:** ${task.priority || 'medium'}
**Dependencies:** ${task.dependencies?.length > 0 ? task.dependencies.map(d => `[${d}]`).join(', ') : 'None'}

## Description

${task.description}

${task.details ? `

## Details

${task.details}
` : ''}

${task.testStrategy ? `

## Test Strategy

${task.testStrategy}
` : ''}

${task.subtasks && task.subtasks.length > 0 ? `

## Subtasks (${task.subtasks.filter(s => s.status === 'done').length}/${task.subtasks.length} complete)

${task.subtasks.map((subtask, i) => {
  const statusIcon = {
    'done': '',
    'in-progress': '',
    'blocked': '',
    'pending': '',
    'cancelled': '',
    'deferred': ''
  }[subtask.status] || '';
  return `${i + 1}. ${statusIcon} [${task.id}.${subtask.id || i + 1}] ${subtask.title} - ${subtask.status}`;
}).join('\n')}
` : ''}
```

### 3. Present Action Menu

**Ask the user what they would like to do:**

```markdown
## Actions

What would you like to do with this task?

1.  **Work on this task** - Set to in-progress and begin implementation
    ${task.status !== 'in-progress' ? `2.  **Set to in-progress** - Mark as currently being worked on` : ''}
2.  **Set to done** - Mark as complete
3.  **Set to cancelled** - Cancel this task
4.  **Set to deferred** - Defer for later

Enter your choice (1-5):
```

### 4. Handle User Choice

**Based on user selection:**

### Choice 1: Work on this task

```javascript
// Set task to in-progress
mcp__task_master_ai__set_task_status({
  projectRoot: process.cwd(),
  id: task.id,
  status: 'in-progress',
});

// Show task details and next steps
// Suggest implementation approach
```

### Choice 2: Set to in-progress (only shown if not already in-progress)

```javascript
mcp__task_master_ai__set_task_status({
  projectRoot: process.cwd(),
  id: task.id,
  status: 'in-progress',
});
```

### Choice 3: Set to done

```javascript
mcp__task_master_ai__set_task_status({
  projectRoot: process.cwd(),
  id: task.id,
  status: 'done',
});
```

### Choice 4: Set to cancelled

```javascript
mcp__task_master_ai__set_task_status({
  projectRoot: process.cwd(),
  id: task.id,
  status: 'cancelled',
});
```

### Choice 5: Set to deferred

```javascript
mcp__task_master_ai__set_task_status({
  projectRoot: process.cwd(),
  id: task.id,
  status: 'deferred',
});
```

### 5. Confirm Action

```markdown
Task [${task.id}] status updated to **${newStatus}**

${newStatus === 'in-progress' ? `
**Next Steps:**

1. Review task description and requirements
2. Check dependencies are met
3. Begin implementation
4. Use \`/task:next\` to see next recommended subtask or task
   ` : ''}

${newStatus === 'done' ? `
**Task Complete!**

Use \`/task:next\` to get the next available task.
` : ''}
```

---

## Performance Optimization

**Keep it fast:**

-  Skip subtask details in initial view
-  Minimal MCP calls (2 calls maximum)
-  No complexity analysis or validation
-  Simple recommendation based on:
  - Status (prefer continuing in-progress first)
  - Dependencies (unblocked tasks only)
  - Priority (high > medium > low)
  - Sequence (follow task ID order)

**For deeper analysis, use `/task:next` instead.**

## When to Use

| Command                   | Use Case                           | Speed | Detail        |
| ------------------------- | ---------------------------------- | ----- | ------------- |
| `/task` or `/task:status` | Daily status check, quick overview | Fast  | High-level    |
| `/task:status <id>`       | View and manage specific task      | Fast  | Task-specific |
| `/task:next`              | Start new work with full context   | Slow  | Comprehensive |

**Use `/task:status` (no argument) when:**

- Quick status check needed
- Daily standup preparation
- Checking what's in progress
- Quick decision on what to work on

**Use `/task:status <id>` (with task ID) when:**

- Need to check status of specific task
- Want to update task status quickly
- Ready to start work on a known task
- Need task details without full analysis

**Use `/task:next` when:**

- Starting new task (needs validation)
- Complex project state
- Want intelligent recommendation
- Need task refinement (--refine flag)