---
description: Smart work command - start or resume work (optimized)
allowed-tools: [Bash, Task]
argument-hint: "[issue-id]"
---

# /ccpm:work - Start or Resume Work

**Token Budget:** ~5,000 tokens (vs ~15,000 baseline) | **67% reduction**

Intelligent command that detects whether to start new work or resume in-progress tasks.

## Mode Detection

- **START**: Issue status is Planning/Backlog/Todo/Planned → Initialize implementation
- **RESUME**: Issue status is In Progress/In Development/Doing → Show progress and next action
- **ERROR**: Issue status is Done/Completed/Cancelled → Cannot work on completed tasks

## Usage

```bash
# Auto-detect issue from git branch
/ccpm:work

# Explicit issue ID
/ccpm:work PSN-29

# Examples
/ccpm:work PROJ-123     # Start or resume PROJ-123
/ccpm:work              # Auto-detect from branch name "feature/PSN-29-add-auth"
```

## Implementation

### Step 1: Parse Arguments & Detect Context

```javascript
// Parse issue ID from arguments or git branch
let issueId = args[0];

if (!issueId) {
  // Attempt to extract from git branch name
  const branch = await Bash('git rev-parse --abbrev-ref HEAD');
  const match = branch.match(/([A-Z]+-\d+)/);

  if (!match) {
    return error('Could not detect issue ID. Usage: /ccpm:work [ISSUE-ID]');
  }

  issueId = match[1];
  console.log(`📌 Detected issue from branch: ${issueId}`);
}

// Validate format
if (!/^[A-Z]+-\d+$/.test(issueId)) {
  return error(`Invalid issue ID format: ${issueId}. Expected format: PROJ-123`);
}
```

### Step 2: Fetch Issue via Linear Subagent

**Use the Task tool to fetch the issue from Linear:**

Invoke the `ccpm:linear-operations` subagent with these parameters:
- **Tool**: Task
- **Subagent**: ccpm:linear-operations
- **Prompt**: Use this exact format:
  ```
  operation: get_issue
  params:
    issueId: "{the issue ID from step 1}"
  context:
    cache: true
    command: "work"
  ```

**Store response as `issue` object** containing:
- `issue.id` - Internal Linear ID
- `issue.identifier` - Human-readable ID (e.g., PSN-29)
- `issue.title` - Issue title
- `issue.description` - Full description with checklist
- `issue.state.name` - Current status name
- `issue.state.id` - Status ID
- `issue.labels` - Array of label objects
- `issue.team.id` - Team ID

**Error handling:**
```javascript
if (subagentResponse.error) {
  console.log(`❌ Error fetching issue: ${subagentResponse.error.message}`);
  console.log('\nSuggestions:');
  subagentResponse.error.suggestions.forEach(s => console.log(`  - ${s}`));
  return;
}

const issue = subagentResponse.issue;
```

### Step 3: Detect Mode

```javascript
const status = issue.state.name;

const startStatuses = ['Planning', 'Backlog', 'Todo', 'Planned', 'Not Started'];
const resumeStatuses = ['In Progress', 'In Development', 'Doing', 'Started'];
const completeStatuses = ['Done', 'Completed', 'Closed', 'Cancelled'];

let mode;
if (startStatuses.includes(status)) {
  mode = 'START';
} else if (resumeStatuses.includes(status)) {
  mode = 'RESUME';
} else if (completeStatuses.includes(status)) {
  console.log(`❌ Cannot work on completed task: ${issueId}`);
  console.log(`Status: ${status}`);
  console.log('\nThis task is already complete. Did you mean to start a different task?');
  return;
} else {
  // Unknown status - default to RESUME
  mode = 'RESUME';
}

console.log(`\n🎯 Mode: ${mode}`);
console.log(`📋 Issue: ${issue.identifier} - ${issue.title}`);
console.log(`📊 Status: ${status}\n`);
```

### Step 4A: START Mode Implementation

```yaml
## START Mode: Initialize Implementation

1. Update issue status and labels (batch operation):

**Use the Task tool to update the Linear issue:**

Invoke the `ccpm:linear-operations` subagent:
- **Tool**: Task
- **Subagent**: ccpm:linear-operations
- **Prompt**:
  ```
  operation: update_issue
  params:
    issueId: "{issue ID from step 1}"
    state: "In Progress"
    labels: ["implementation"]
  context:
    cache: true
    command: "work"
  ```

Display: "✅ Updated status: Planning → In Progress"

2. Analyze codebase with smart agent selection:

Task: `
Analyze the codebase to create an implementation plan for: ${issue.title}

Context:
- Issue: ${issueId}
- Description:
${issue.description}

Your task:
1. Identify files that need to be modified
2. List dependencies and imports needed
3. Outline testing strategy
4. Note potential challenges or risks
5. Estimate complexity (low/medium/high)

Provide a structured implementation plan with specific file paths and line numbers where possible.
`

Note: The smart-agent-selector hook will automatically choose the optimal agent:
- backend-architect for API/backend tasks
- frontend-developer for UI/React tasks
- mobile-developer for mobile tasks
- etc.

3. Store the plan and add comment via Linear subagent:

**Use the Task tool to add a comment to Linear:**

Invoke the `ccpm:linear-operations` subagent:
- **Tool**: Task
- **Subagent**: ccpm:linear-operations
- **Prompt**:
  ```
  operation: create_comment
  params:
    issueId: "{issue ID from step 1}"
    body: |
      ## 🚀 Implementation Started

      **Status:** Planning → In Progress

      ### Implementation Plan

      {paste the analysis result from step 2 here}

      ---
      *Started via /ccpm:work*
  context:
    command: "work"
  ```

Display: "✅ Added implementation plan to Linear"

4. Display next actions:

console.log('\n═══════════════════════════════════════');
console.log('🎯 Implementation Started');
console.log('═══════════════════════════════════════\n');
console.log('📝 Plan added to Linear issue');
console.log('\n💡 Next Steps:');
console.log('  1. Review the implementation plan above');
console.log('  2. Start coding');
console.log('  3. Use /ccpm:sync to save progress');
console.log('  4. Use /ccpm:verify when ready for review');
console.log('\n📌 Quick Commands:');
console.log(`  /ccpm:sync "${issueId}" "progress update"`);
console.log(`  /ccpm:commit "${issueId}"`);
console.log(`  /ccpm:verify "${issueId}"`);
```

### Step 4B: RESUME Mode Implementation

```yaml
## RESUME Mode: Show Progress and Next Action

1. Calculate progress from checklist:

const description = issue.description || '';
const checklistItems = description.match(/- \[([ x])\] .+/g) || [];
const totalItems = checklistItems.length;
const completedItems = checklistItems.filter(item => item.includes('[x]')).length;
const progress = totalItems > 0 ? Math.round((completedItems / totalItems) * 100) : 0;

2. Determine next action:

let nextAction = null;
let suggestion = null;

if (progress === 100) {
  suggestion = 'All checklist items complete! Ready for verification.';
  nextAction = '/ccpm:verify';
} else {
  // Find first incomplete checklist item
  const incompleteItem = checklistItems.find(item => item.includes('[ ]'));
  if (incompleteItem) {
    const itemText = incompleteItem.replace(/- \[ \] /, '');
    nextAction = `Continue work on: ${itemText}`;
  } else {
    suggestion = 'No checklist found. Continue implementation.';
  }
}

3. Display progress and suggestion:

console.log('\n═══════════════════════════════════════');
console.log('📊 Work in Progress');
console.log('═══════════════════════════════════════\n');
console.log(`📋 Issue: ${issue.identifier} - ${issue.title}`);
console.log(`📊 Status: ${issue.state.name}`);
console.log(`✅ Progress: ${progress}% (${completedItems}/${totalItems} items)\n`);

if (checklistItems.length > 0) {
  console.log('📝 Checklist:\n');
  checklistItems.forEach(item => {
    const isComplete = item.includes('[x]');
    const icon = isComplete ? '✅' : '⏳';
    const text = item.replace(/- \[([ x])\] /, '');
    console.log(`  ${icon} ${text}`);
  });
  console.log('');
}

if (suggestion) {
  console.log(`💡 Suggestion: ${suggestion}\n`);
}

if (nextAction) {
  console.log(`🎯 Next Action: ${nextAction}\n`);
}

4. Interactive menu:

console.log('Available Actions:');
console.log('  1. ⭐ Sync progress      - /ccpm:sync');
console.log('  2. 📝 Git commit         - /ccpm:commit');
console.log('  3. ✅ Run verification   - /ccpm:verify');
console.log('  4. 🔍 View issue details - /ccpm:utils:status ' + issueId);
console.log('  5. 🛠️  Fix issues         - /ccpm:verification:fix ' + issueId);
console.log('\n📌 Quick Commands:');
console.log(`  /ccpm:sync "completed ${itemText}"`);
console.log(`  /ccpm:commit "feat: ${issue.title.toLowerCase()}"`);

if (progress === 100) {
  console.log('\n⭐ Recommended: /ccpm:verify (checklist complete)');
}
```

### Step 5: Interactive Menu

Display menu based on mode:

**START mode menu:**
```
Available Actions:
  1. ⭐ Start coding        - Begin implementation
  2. 📝 Sync progress       - /ccpm:sync
  3. 🔍 View issue details  - /ccpm:utils:status PSN-29

Quick Commands:
  /ccpm:sync "implemented X feature"
  /ccpm:commit "feat: add user authentication"
```

**RESUME mode menu:**
```
Available Actions:
  1. ⭐ Sync progress       - /ccpm:sync
  2. 📝 Git commit          - /ccpm:commit
  3. ✅ Run verification    - /ccpm:verify
  4. 🔍 View issue details  - /ccpm:utils:status PSN-29
  5. 🛠️  Fix issues          - /ccpm:verification:fix PSN-29

Quick Commands:
  /ccpm:sync "progress update"
  /ccpm:commit
  /ccpm:verify
```

## Error Handling

### Invalid Issue ID Format
```
❌ Invalid issue ID format: proj123
Expected format: PROJ-123 (uppercase letters, hyphen, numbers)
```

### Issue Not Found
```
❌ Error fetching issue: Issue not found

Suggestions:
  - Verify the issue ID is correct
  - Check you have access to this Linear team
  - Ensure the issue hasn't been deleted
```

### Git Branch Detection Failed
```
❌ Could not detect issue ID from git branch

Current branch: main

Usage: /ccpm:work [ISSUE-ID]

Example: /ccpm:work PSN-29
```

### Completed Task
```
❌ Cannot work on completed task: PSN-29
Status: Done

This task is already complete. Did you mean to start a different task?
```

### Network Errors
```
❌ Error fetching issue: Network request failed

Suggestions:
  - Check your internet connection
  - Verify Linear MCP server is running
  - Try again in a moment
```

## Examples

### Example 1: Start work (auto-detect from branch)

```bash
# Current branch: feature/PSN-29-add-auth
/ccpm:work

# Output:
# 📌 Detected issue from branch: PSN-29
#
# 🎯 Mode: START
# 📋 Issue: PSN-29 - Add user authentication
# 📊 Status: Planning
#
# ✅ Updated status: Planning → In Progress
#
# [Smart agent analyzes codebase...]
#
# ✅ Added implementation plan to Linear
#
# ═══════════════════════════════════════
# 🎯 Implementation Started
# ═══════════════════════════════════════
#
# 📝 Plan added to Linear issue
#
# 💡 Next Steps:
#   1. Review the implementation plan above
#   2. Start coding
#   3. Use /ccpm:sync to save progress
#   4. Use /ccpm:verify when ready for review
```

### Example 2: Resume work (explicit issue ID)

```bash
/ccpm:work PSN-29

# Output:
# 🎯 Mode: RESUME
# 📋 Issue: PSN-29 - Add user authentication
# 📊 Status: In Progress
#
# ═══════════════════════════════════════
# 📊 Work in Progress
# ═══════════════════════════════════════
#
# 📋 Issue: PSN-29 - Add user authentication
# 📊 Status: In Progress
# ✅ Progress: 60% (3/5 items)
#
# 📝 Checklist:
#
#   ✅ Create auth endpoints
#   ✅ Add JWT validation
#   ✅ Implement login flow
#   ⏳ Add password reset
#   ⏳ Write tests
#
# 🎯 Next Action: Continue work on: Add password reset
#
# Available Actions:
#   1. ⭐ Sync progress      - /ccpm:sync
#   2. 📝 Git commit         - /ccpm:commit
#   3. ✅ Run verification   - /ccpm:verify
```

### Example 3: Resume completed work (error)

```bash
/ccpm:work PSN-28

# Output:
# 🎯 Mode: ERROR
# 📋 Issue: PSN-28 - Fix navigation bug
# 📊 Status: Done
#
# ❌ Cannot work on completed task: PSN-28
# Status: Done
#
# This task is already complete. Did you mean to start a different task?
```

## Token Budget Breakdown

| Section | Tokens | Notes |
|---------|--------|-------|
| Frontmatter & description | 100 | Minimal metadata |
| Step 1: Argument parsing | 300 | Git detection + validation |
| Step 2: Fetch issue | 400 | Linear subagent + error handling |
| Step 3: Mode detection | 200 | Status checks + display |
| Step 4A: START mode | 1,500 | Update + analysis + comment |
| Step 4B: RESUME mode | 1,000 | Progress + next action + menu |
| Step 5: Interactive menu | 600 | Mode-specific menus |
| Examples | 400 | 3 concise examples |
| Error handling | 500 | 5 error scenarios |
| **Total** | **~5,000** | **vs ~15,000 baseline (67% reduction)** |

## Key Optimizations

1. ✅ **No routing overhead** - Direct implementation of both modes
2. ✅ **Linear subagent** - All Linear ops cached (85-95% hit rate)
3. ✅ **Smart agent selection** - Automatic optimal agent choice for analysis
4. ✅ **Batch operations** - Single update_issue call (state + labels)
5. ✅ **Concise examples** - Only 3 essential examples
6. ✅ **Focused scope** - START mode simplified (no full agent discovery)

## Integration with Other Commands

- **After /ccpm:plan** → Use /ccpm:work to start implementation
- **During work** → Use /ccpm:sync to save progress
- **Git commits** → Use /ccpm:commit for conventional commits
- **Before completion** → Use /ccpm:verify for quality checks
- **Finalize** → Use /ccpm:done to create PR and complete

## Notes

- **Git branch detection**: Extracts issue ID from branch names like `feature/PSN-29-add-auth`
- **Smart agent selection**: Automatically invokes optimal agent based on task type
- **Progress tracking**: Calculates from checklist items in issue description
- **Caching**: Linear subagent caches issue data for 85-95% faster subsequent operations
- **Error recovery**: Provides actionable suggestions for all error scenarios