---
name: LLM-Native Progress Tracker
version: 1.0.0
role: Track and analyze parallel development progress
description: Provides intelligent progress tracking with predictive analytics and real-time insights for parallel execution
capabilities:
  - Multi-dimensional progress analysis
  - Natural language understanding
  - Predictive completion forecasting
  - Real-time dashboards
  - Blocker detection and resolution
---

# LLM-Native Progress Tracker

## Purpose

Provides intelligent progress tracking and visualization for parallel development execution. Uses LLM analysis to understand actual progress beyond simple status updates, identifying blockers, predicting delays, and suggesting optimizations.

## Core Capabilities

### 1. Multi-Dimensional Progress Analysis

- **Code Progress**: Actual implementation completion
- **Quality Progress**: Test coverage and standards
- **Integration Progress**: How well parts fit together
- **Risk Progress**: Mitigation of identified risks

### 2. Intelligent Status Interpretation

- **Natural Language Processing**: Understand developer updates
- **Code Analysis**: Verify claimed progress
- **Pattern Recognition**: Identify common delays
- **Predictive Analytics**: Forecast completion times

### 3. Real-Time Dashboards

- **Visual Progress Maps**: Wave and agent status
- **Dependency Graphs**: Show blocking relationships
- **Quality Metrics**: Live test and coverage data
- **Risk Indicators**: Early warning system

## Progress Tracking Framework

### Status Collection Structure

```json
{
  "trackingId": "sprint-2024-03-execution",
  "timestamp": "2024-03-15T10:30:00Z",
  "waves": {
    "wave1": {
      "status": "in-progress",
      "startTime": "2024-03-15T09:00:00Z",
      "agents": {
        "AUTH_IMPL": {
          "status": "active",
          "progress": 65,
          "lastUpdate": "Implemented OAuth2 flow, working on refresh tokens",
          "metrics": {
            "filesModified": 12,
            "testsWritten": 18,
            "testsPassing": 16,
            "codeCoverage": 78
          },
          "blockers": [],
          "estimatedCompletion": "45 minutes"
        }
      }
    }
  },
  "overallHealth": "green",
  "risks": ["wave2 dependency on AUTH might delay by 30min"],
  "recommendations": ["Consider starting CACHE agent early"]
}
```

### Progress Analysis Prompts

```markdown
You are an expert project manager analyzing parallel development progress. Based on the status updates, provide insights about actual progress, potential issues, and recommendations.

## Current Status:

[Provide agent statuses, code metrics, and updates]

## Analysis Tasks:

1. **Progress Verification**
   - Compare claimed progress with code metrics
   - Identify any discrepancies
   - Assess quality of completed work

2. **Blocker Detection**
   - Identify hidden blockers not explicitly reported
   - Predict upcoming blockers
   - Suggest preventive actions

3. **Timeline Analysis**
   - Calculate realistic completion times
   - Identify agents at risk of delay
   - Suggest timeline optimizations

4. **Quality Assessment**
   - Evaluate test coverage trends
   - Identify quality risks
   - Recommend quality improvements

5. **Optimization Opportunities**
   - Suggest resource reallocation
   - Identify parallelization opportunities
   - Recommend process improvements

Provide actionable insights with specific recommendations.
```

## Intelligent Tracking Features

### 1. Natural Language Understanding

```javascript
class ProgressAnalyzer {
  async analyzeUpdate(agentId, updateText) {
    const analysis = await this.llm.analyze({
      prompt: `
        Agent ${agentId} reports: "${updateText}"
        
        Extract:
        1. Actual work completed
        2. Work remaining
        3. Implicit blockers
        4. Quality concerns
        5. Time estimates
        
        Return structured analysis.
      `,
      context: this.projectContext,
    });

    return {
      completedTasks: analysis.completed,
      remainingWork: analysis.remaining,
      hiddenBlockers: analysis.blockers,
      qualityRisks: analysis.quality,
      revisedEstimate: analysis.timeEstimate,
    };
  }
}
```

### 2. Progress Visualization Templates

#### Console Dashboard

```
┌─────────────────────────────────────────────────────────────┐
│ PARALLEL EXECUTION PROGRESS - Sprint 2024-03               │
├─────────────────────────────────────────────────────────────┤
│ Overall Progress: ████████████░░░░░░ 65% (On Track)        │
├─────────────────────────────────────────────────────────────┤
│ WAVE 1 (Active)                          Started: 1h ago   │
│ ├─ AUTH_IMPL    [████████░░░░] 65%  ✓ Tests: 16/18        │
│ ├─ LOG_IMPL     [██████████░░] 80%  ✓ Tests: 24/24        │
│ └─ CACHE_IMPL   [██████░░░░░░] 45%  ⚠ Coverage: 62%       │
├─────────────────────────────────────────────────────────────┤
│ WAVE 2 (Pending)                         ETA: 45 min       │
│ ├─ PROFILE_IMPL [░░░░░░░░░░░░] 0%   ⚠ Depends on AUTH    │
│ └─ ADMIN_IMPL   [░░░░░░░░░░░░] 0%   ✓ Ready to start     │
├─────────────────────────────────────────────────────────────┤
│ Risks: AUTH delay might impact PROFILE timeline            │
│ Recommendation: Start ADMIN_IMPL early in Wave 2           │
└─────────────────────────────────────────────────────────────┘
```

#### Markdown Report

```markdown
# Parallel Execution Progress Report

**Generated**: 2024-03-15 10:30 AM
**Sprint**: 2024-03
**Overall Status**: 🟢 On Track

## Executive Summary

- **Progress**: 65% complete (13/20 stories)
- **Timeline**: On schedule for completion by EOD
- **Quality**: 94% test coverage maintained
- **Risks**: 1 medium risk identified

## Wave Status

### Wave 1 (Active) - 75% Complete

| Agent      | Progress | Status    | Quality         | ETA |
| ---------- | -------- | --------- | --------------- | --- |
| AUTH_IMPL  | 65%      | 🟡 Active | ✅ 89% coverage | 45m |
| LOG_IMPL   | 80%      | 🟡 Active | ✅ 96% coverage | 20m |
| CACHE_IMPL | 45%      | 🟡 Active | ⚠️ 62% coverage | 1h  |

**Key Updates**:

- AUTH: OAuth2 flow complete, working on refresh tokens
- LOG: Structured logging implemented, finalizing tests
- CACHE: Redis integration in progress, some test failures

### Wave 2 (Pending) - 0% Complete

| Agent        | Progress | Status     | Dependencies | Ready |
| ------------ | -------- | ---------- | ------------ | ----- |
| PROFILE_IMPL | 0%       | ⏸️ Waiting | AUTH_IMPL    | ❌    |
| ADMIN_IMPL   | 0%       | ✅ Ready   | None         | ✅    |

## Risk Analysis

### Identified Risks

1. **AUTH Delay Impact** (MEDIUM)
   - Risk: AUTH completion might delay PROFILE start
   - Impact: 30-minute delay to Wave 2
   - Mitigation: Start ADMIN_IMPL independently

2. **CACHE Test Coverage** (LOW)
   - Risk: Coverage below 70% threshold
   - Impact: Quality gate failure
   - Mitigation: Prioritize test writing

## Recommendations

1. **Immediate Actions**
   - Allocate additional resources to AUTH_IMPL
   - Start ADMIN_IMPL early in Wave 2
   - Focus on CACHE test coverage

2. **Process Improvements**
   - Consider smaller work items for better parallelization
   - Implement continuous integration for faster feedback
   - Add progress webhooks for real-time updates
```

### 3. Predictive Analytics

```javascript
class ProgressPredictor {
  async predictCompletion(currentProgress) {
    const prediction = await this.llm.analyze({
      prompt: `
        Based on current progress data:
        ${JSON.stringify(currentProgress)}
        
        And historical patterns:
        - Similar sprints completion rates
        - Team velocity trends
        - Common blocker patterns
        
        Predict:
        1. Likely completion time for each agent
        2. Probability of on-time delivery
        3. Potential delays and causes
        4. Optimization opportunities
      `,
      historicalData: this.getHistoricalData(),
    });

    return {
      predictions: prediction.agentCompletions,
      confidence: prediction.confidenceLevel,
      risks: prediction.identifiedRisks,
      optimizations: prediction.suggestions,
    };
  }
}
```

## Integration Patterns

### Real-Time Updates

```javascript
// WebSocket integration for live updates
class LiveProgressTracker {
  constructor(orchestrator) {
    this.orchestrator = orchestrator;
    this.subscribers = [];
  }

  async trackProgress() {
    setInterval(async () => {
      const status = await this.orchestrator.getStatus();
      const analysis = await this.analyzeProgress(status);

      this.broadcast({
        type: "progress-update",
        data: {
          raw: status,
          analysis: analysis,
          visualization: this.generateVisual(analysis),
        },
      });
    }, 30000); // Every 30 seconds
  }
}
```

### Slack Integration

```javascript
// Automated progress notifications
async function sendProgressUpdate(progress) {
  const summary = await llm.generateSummary(progress);

  await slack.postMessage({
    channel: "#dev-team",
    blocks: [
      {
        type: "section",
        text: {
          type: "mrkdwn",
          text: `*Parallel Execution Update*\n${summary}`,
        },
      },
      {
        type: "section",
        fields: progress.waves.map((wave) => ({
          type: "mrkdwn",
          text: `*${wave.name}*\n${wave.status} - ${wave.progress}%`,
        })),
      },
    ],
  });
}
```

## Advanced Analytics

### 1. Velocity Tracking

```yaml
Metrics:
  - Story points per hour
  - Code lines per agent
  - Test coverage trends
  - Quality gate pass rates
  - Blocker resolution time
```

### 2. Pattern Recognition

```yaml
Common Patterns:
  - Morning productivity peaks
  - Post-lunch slowdowns
  - Integration bottlenecks
  - Test writing delays
  - Documentation gaps
```

### 3. Optimization Suggestions

```yaml
Optimizations:
  - Ideal wave sizes
  - Optimal agent allocation
  - Best parallelization strategies
  - Quality gate timing
  - Resource utilization
```

## Usage Examples

### Basic Progress Check

```bash
# Get current progress
llm-track progress --execution-id sprint-2024-03

# Get detailed analysis
llm-track analyze --execution-id sprint-2024-03 --verbose
```

### Continuous Monitoring

```bash
# Start live monitoring
llm-track monitor --execution-id sprint-2024-03 --interval 30s

# With notifications
llm-track monitor --notify slack,email --alert-on risks
```

### Historical Analysis

```bash
# Analyze patterns
llm-track history --last-sprints 10 --identify-patterns

# Predict current sprint
llm-track predict --based-on historical --confidence-level
```

## Benefits

1. **Deep Insights**: Beyond simple progress percentages
2. **Early Warning**: Identify issues before they impact
3. **Optimization**: Continuous improvement suggestions
4. **Transparency**: Clear view for all stakeholders
5. **Predictability**: Data-driven completion estimates
6. **Quality Focus**: Integrated quality tracking

This intelligent progress tracker transforms parallel execution monitoring from passive reporting to active optimization and risk management.