devteam-implement

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               Upgrade
   + Report                Model

   Max Iterations: 10 (normal) / 10 (eco, slower escalation)

Escalation thresholds:

| Mode | haiku->sonnet | sonnet->opus | opus->council | |------|--------------|-------------|--------------| | Normal | 2 failures | 2 failures | 3 failures | | Eco | 4 failures | 4 failures | 4 failures |

Phase 6: Quality Gates

Run all applicable quality gates:

const gates = [
    { name: 'tests', command: 'npm test', required: true },
    { name: 'typecheck', command: 'npm run typecheck', required: true },
    { name: 'lint', command: 'npm run lint', required: true },
    { name: 'security', command: 'npm audit', required: false },
    { name: 'coverage', command: 'npm run coverage', threshold: 80 }
]

for (const gate of gates) {
    const result = await runGate(gate)
    log_gate_passed(gate.name) // or log_gate_failed()

    if (!result.passed && gate.required) {
        createFixTask(gate, result.errors)
    }
}

Phase 7: Completion

On success:

log_session_ended('completed', 'All quality gates passed')
end_session('completed', 'Success')

// Output completion message
console.log(`
IMPLEMENTATION COMPLETE

Task: ${taskDescription}

Files Changed:
${filesChanged.map(f => `  - ${f}`).join('\n')}

Quality Gates:
  Tests: ${testCount} passing
  Types: No errors
  Lint: Clean
  Coverage: ${coverage}%

Iterations: ${iterations}
Model Usage: ${modelBreakdown}
Cost: $${totalCost}

EXIT_SIGNAL: true
`)

On max iterations:

log_session_ended('failed', 'Max iterations reached')
end_session('failed', 'Max iterations reached')

console.log(`
MAX ITERATIONS REACHED

The task could not be completed within ${maxIterations} iterations.

Remaining Issues:
${remainingIssues.map(i => `  - ${i}`).join('\n')}

Recommendation: Review the issues above and either:
1. Run /devteam:implement again with more context
2. Break the task into smaller pieces
3. Manually address the blocking issues

EXIT_SIGNAL: true
`)

Automatic Worktree Management

Worktrees are fully automatic. Users never need to interact with worktrees directly - the system creates, uses, merges, and cleans them up transparently.

When Worktrees Are Created

Worktrees are automatically created when:

• A plan has multiple p