/devteam-implement

name: devteam-implement
description: Execute implementation work - plans, sprints, tasks, or ad-hoc work.
argument-hint: [task] [--sprint <id>] [--all] [--task <id>] [--eco] [--skip-interview] [--type <type>] [--model <model>]
user-invocable: true
allowed-tools: Read, Edit, Write, Glob, Grep, Bash, Task
model: opus

Current session: !`source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh" && get_current_session 2>/dev/null || echo "No active session"` Active sprint: !`source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh" && get_kv_state "active_sprint" 2>/dev/null || echo "None"` Failure count: !`source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh" && get_kv_state "consecutive_failures" 2>/dev/null || echo "0"`

DevTeam Implement Command

**Command:** `/devteam:implement [task] [options]`

Execute implementation work - plans, sprints, tasks, or ad-hoc work.

Usage

# Execute selected/current plan
/devteam:implement

# Execute specific sprint
/devteam:implement --sprint 1
/devteam:implement --sprint SPRINT-001

# Execute all sprints
/devteam:implement --all

# Execute specific task
/devteam:implement --task TASK-001

# Ad-hoc task (will trigger interview if ambiguous)
/devteam:implement "Add pagination to user list"

# Cost-optimized execution
/devteam:implement --eco
/devteam:implement --sprint 1 --eco

# Skip interview for ad-hoc tasks
/devteam:implement "Fix typo in header" --skip-interview

# Specify task type for better agent selection
/devteam:implement "Audit auth flow" --type security
/devteam:implement "Restructure utils" --type refactor

Options

| Option | Description | |--------|-------------| | `--sprint <id>` | Execute specific sprint | | `--all` | Execute all sprints sequentially | | `--task <id>` | Execute specific task | | `--eco` | Cost-optimized execution (slower escalation, summarized context) | | `--skip-interview` | Skip ambiguity check for ad-hoc tasks | | `--type <type>` | Specify task type: feature, bug, security, refactor, docs | | `--model <model>` | Force starting model: haiku, sonnet, opus | | `--max-iterations <n>` | Override max iterations (default: 10) | | `--show-worktrees` | Debug: Show worktree operations (normally hidden) |

Your Process

Phase 0: Initialize Session

# Source state management
source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh"
source "${CLAUDE_PLUGIN_ROOT}/scripts/events.sh"

# Start session
SESSION_ID=$(start_session "/devteam:implement $*" "implement")
log_session_started "/devteam:implement $*" "implement"

# Determine execution mode
if [[ "$*" == *"--eco"* ]]; then
    set_state "execution_mode" "eco"
fi

Create/update session in database:

INSERT INTO sessions (
    id, command, command_type, execution_mode, status, current_phase
) VALUES (
    'session-xxx', '/devteam:implement --sprint 1', 'implement', 'normal', 'running', 'initializing'
);

Phase 1: Determine Execution Target

**Priority order:** 1. `--task TASK-001` -> Execute single task 2. `--sprint 1` -> Execute specific sprint 3. `--all` -> Execute all sprints 4. `"ad-hoc task"` -> Create and execute ad-hoc task 5. (no args) -> Execute current/selected plan

function determineTarget(args) {
    if (args.task) return { type: 'task', id: args.task }
    if (args.sprint) return { type: 'sprint', id: args.sprint }
    if (args.all) return { type: 'all_sprints' }
    if (args._.length > 0) return { type: 'adhoc', description: args._.join(' ') }
    return { type: 'plan', id: getSelectedPlan() }
}

Phase 2: Interview (for ad-hoc tasks)

**Skip if:**

• `--skip-interview` flag present
• Task is from a plan (already has context)
• Description is clearly unambiguous

**Trigger interview if:**

• Ad-hoc task with vague description
• Missing critical information

// Check for ambiguity
const ambiguityIndicators = [
    description.split(' ').length < 5,           // Too short
    /fix|broken|doesn't work|issue/i.test(description) && !description.includes('when'),
    /add|create|implement/i.test(description) && !description.includes('to'),
    !description.includes(' ')                    // Single word
]

if (ambiguityIndicators.some(x => x) && !args.noInterview) {
    await runInterview('adhoc_task', description)
}

**Interview questions for ad-hoc tasks:**

adhoc_task:
  triggers:
    - pattern: "fix|broken|bug"
      redirect: bug_interview
    - pattern: "add|create|implement"
      questions:
        - key: scope
          question: "What component/area should this be added to?"
        - key: requirements
          question: "What are the specific requirements?"
        - key: acceptance
          question: "How will we know when this is complete?"

Phase 3: Agent Selection

Based on task type and content, select appropriate agents.

# Agent selection weights
selection_weights:
  keywords: 40%
  file_types: 30%
  task_type: 20%
  language: 10%

# Task type overrides
task_type_agents:
  security:
    primary: quality:security-auditor
    support: [security:penetration-tester, security:compliance-engineer]
  refactor:
    primary: quality:refactoring-coordinator
    support: [frontend:code-reviewer]
  bug:
    primary: diagnosis:root-cause-analyst
    support: [orchestration:bug-council-orchestrator]

Phase 4: Model Selection

**Normal Mode:**

complexity_based:
  1-4: haiku
  5-8: sonnet
  9-14: opus

**Eco Mode:**

eco_mode:
  default: haiku
  exceptions:
    - security: sonnet
    - architecture: sonnet
    - complexity_10_plus: sonnet

Phase 5: Execute with Task Loop

TASK LOOP

   Execute       <-------- Fix Tasks
   Agent(s)                    |
      |                        |
      v                        |
   Quality    -- FAIL -->  Create Fix
    Gates                   Tasks
      |                        |
     PASS                  ESCALATE?
      |                        |
      v                        v
   Complete