/implement

description: "Execute tasks from a track's implementation plan following TDD workflow"
argument-hint: "[track-id] [--task X.Y] [--phase N]"

Implement Track

Execute tasks from a track's implementation plan, following the workflow rules defined in `conductor/workflow.md`.

Pre-flight Checks

1. Verify Conductor is initialized:

• Check `conductor/product.md` exists
• Check `conductor/workflow.md` exists
• Check `conductor/tracks.md` exists
• If missing: Display error and suggest running `/conductor:setup` first

2. Load workflow configuration:

• Read `conductor/workflow.md`
• Parse TDD strictness level
• Parse commit strategy
• Parse verification checkpoint rules

Track Selection

If argument provided:

• Validate track exists: `conductor/tracks/{argument}/plan.md`
• If not found: Search for partial matches, suggest corrections

If no argument:

1. Read `conductor/tracks.md` 2. Parse for incomplete tracks (status `[ ]` or `[~]`) 3. Display selection menu:

   Select a track to implement:

   In Progress:
   1. [~] auth_20250115 - User Authentication (Phase 2, Task 3)

   Pending:
   2. [ ] nav-fix_20250114 - Navigation Bug Fix
   3. [ ] dashboard_20250113 - Dashboard Feature

   Enter number or track ID:

Context Loading

Load all relevant context for implementation:

1. Track documents:

• `conductor/tracks/{trackId}/spec.md` - Requirements
• `conductor/tracks/{trackId}/plan.md` - Task list
• `conductor/tracks/{trackId}/metadata.json` - Progress state

2. Project context:

• `conductor/product.md` - Product understanding
• `conductor/tech-stack.md` - Technical constraints
• `conductor/workflow.md` - Process rules

3. Code style (if exists):

• `conductor/code_styleguides/{language}.md`

Track Status Update

Update track to in-progress:

1. In `conductor/tracks.md`:

• Change `[ ]` to `[~]` for this track

2. In `conductor/tracks/{trackId}/metadata.json`:

• Set `status: "in_progress"`
• Update `updated` timestamp

Task Execution Loop

For each incomplete task in plan.md (marked with `[ ]`):

1. Task Identification

Parse plan.md to find next incomplete task:

• Look for lines matching `- [ ] Task X.Y: {description}`
• Track current phase from structure

2. Task Start

Mark task as in-progress:

• Update plan.md: Change `[ ]` to `[~]` for current task
• Announce: "Starting Task X.Y: {description}"

3. TDD Workflow (if TDD enabled in workflow.md)

**Red Phase - Write Failing Test:**

Following TDD workflow for Task X.Y...

Step 1: Writing failing test

• Create test file if needed
• Write test(s) for the task functionality
• Run tests to confirm they fail
• If tests pass unexpectedly: HALT, investigate

**Green Phase - Implement:**

Step 2: Implementing minimal code to pass test

• Write minimum code to make test pass
• Run tests to confirm they pass
• If tests fail: Debug and fix

**Refactor Phase:**

Step 3: Refactoring while keeping tests green

• Clean up code
• Run tests to ensure still passing

4. Non-TDD Workflow (if TDD not strict)

• Implement the task directly
• Run any existing tests
• Manual verification as needed

5. Task Completion

**Commit changes** (following commit strategy from workflow.md):

git add -A
git commit -m "{commit_prefix}: {task description} ({trackId})"

**Update plan.md:**

• Change `[~]` to `[x]` for completed task
• Commit plan update:

git add conductor/tracks/{trackId}/plan.md
git commit -m "chore: mark task X.Y complete ({trackId})"

**Update metadata.json:**

• Increment `tasks.completed`
• Update `updated` timestamp

6. Phase Completion Check

After each task, check if phase is complete:

• Parse plan.md for phase structure
• If all tasks in current phase are `[x]`:

**Run phase verification:**

Phase {N} complete. Running verification...

• Execute verification tasks listed for the phase
• Run full test suite: `npm test` / `pytest` / etc.

**Report and wait for approval:**

Phase {N} Verification Results:
- All phase tasks: Complete
- Tests: {passing/failing}
- Verification: {pass/fail}

Approve to continue to Phase {N+1}?
1. Yes, continue
2. No, there are issues to fix
3. Pause implementation

**CRITICAL: Wait for explicit user approval before proceeding to next phase.**

Error Handling During Implementation

On Tool Failure

ERROR: {tool} failed with: {error message}

Options:
1. Retry the operation
2. Skip this task and continue
3. Pause implementation
4. Revert current task changes

• HALT and present options
• Do NOT automatically continue

On Test Failure

TESTS FAILING after Task X.Y

Failed tests:
- {test name}: {failure reason}

Options:
1. Attempt to fix
2. Rollback task changes
3. Pause for manual intervention

On Git Failure

GIT ERROR: {error message}

This may indicate:
- Uncommitted changes from outside Conductor
- Merge conflicts
- Permission issues

Options:
1. Show git status
2. Attempt to resolve
3. Pause for manual intervention

Track Completion

When all phases and tasks are complete:

1. Final Verification

All tasks complete. Running final verification...

• Run full test suite
• Check all acceptance criteria from spec.md
• Generate verification report

2. Update Track Status

In `conductor/tracks.md`:

• Change `[~]` to `[x]` for this track
• Update the "Updated" column

In `conductor/tracks/{trackId}/metadata.json`:

• Set `status: "complete"`
• Set `phases.completed` to total
• Set `tasks.completed` to total
• Update `updated` timestamp

In `conductor/tracks/{trackId}/plan.md`:

• Update header status to `[x] Complete`

3. Documentation Sync Offer

Track complete! Would you like to sync documentation?

This will update:
- conductor/product.md (if new features added)
- conductor/tech-stack.md (if new dependencies added)
- README.md (if applicable)

1. Yes, sync documentation
2. N