Feature: Real-time agent and user activity status dashboard

## Feature Request

Create a real-time dashboard that shows which agents (AI coding assistants) or users are currently working on tasks, blocked, or idle across the codebase and pull requests.

## Description

A live activity monitor that tracks and displays the status of all agents (Cursor, Devin, Claude Code, Copilot, etc.) and human developers working on the repository, showing what they're working on, their current status, and any blockers they're facing.

## Core Features

### 1. Agent/User Status Types

#### Status Definitions
```javascript
const statusTypes = {
active: {
label: "Actively Working",
color: "green",
icon: "🟢",
description: "Currently making changes",
subStates: [
"writing_code",
"reviewing",
"testing",
"debugging",
"refactoring"
]
},

blocked: {
label: "Blocked",
color: "red",
icon: "🔴",
description: "Waiting on external dependency",
reasons: [
"waiting_for_review",
"merge_conflicts",
"failing_tests",
"missing_permissions",
"api_rate_limited",
"waiting_for_human_input",
"dependency_unavailable"
]
},

idle: {
label: "Idle",
color: "gray",
icon: "⚫",
description: "No recent activity",
threshold: "5 minutes"
},

thinking: {
label: "Processing",
color: "yellow",
icon: "🟡",
description: "Agent is analyzing/planning",
typical_duration: "10-60 seconds"
},

completed: {
label: "Task Complete",
color: "blue",
icon: "🔵",
description: "Finished assigned task"
},

error: {
label: "Error State",
color: "orange",
icon: "🟠",
description: "Encountered an error",
requires_intervention: true
}
};
```

### 2. Activity Dashboard

#### Real-time Activity View
```
┌──────────────────────────────────────────────────────┐
│ 👥 Active Agents & Users (4 active, 2 blocked) │
├──────────────────────────────────────────────────────┤
│ │
│ 🤖 Claude Code 🟢 ACTIVE (2 min) │
│ ├─ Task: Implementing authentication system │
│ ├─ Files: auth.js, middleware.js │
│ ├─ Progress: 60% (6/10 subtasks) │
│ └─ Last action: Modified auth.js │
│ │
│ 🤖 Cursor 🔴 BLOCKED (5 min) │
│ ├─ Task: Refactoring database queries │
│ ├─ Blocker: Merge conflict in db/queries.js │
│ ├─ Waiting for: Human to resolve conflict │
│ └─ Suggested action: Resolve and retry │
│ │
│ 👤 john_doe 🟢 ACTIVE (30 sec) │
│ ├─ Working on: PR #456 review │
│ ├─ Files viewing: components/Header.tsx │
│ └─ Last action: Added review comment │
│ │
│ 🤖 GitHub Copilot 🟡 THINKING (15 sec) │
│ ├─ Processing: Generate unit tests │
│ └─ Context: test/auth.test.js │
│ │
│ 🤖 Devin 🟢 ACTIVE (8 min) │
│ ├─ Task: Setting up CI/CD pipeline │
│ ├─ Progress: 80% complete │
│ └─ Current step: Configuring GitHub Actions │
│ │
│ 👤 sarah_smith ⚫ IDLE (10 min) │
│ └─ Last seen: Viewing README.md │
│ │
└──────────────────────────────────────────────────────┘
```

### 3. Agent Detection & Tracking

#### Agent Identification
```javascript
class AgentDetector {
detectAgents() {
return {
// AI Agents
claudeCode: this.detectClaudeCode(),
cursor: this.detectCursor(),
devin: this.detectDevin(),
copilot: this.detectCopilot(),
codeium: this.detectCodeium(),
tabnine: this.detectTabnine(),

// Human users
humans: this.detectHumanUsers()
};
}

detectAgentActivity(agent) {
return {
// Activity signals
gitActivity: this.checkGitCommits(agent),
fileChanges: this.checkFileModifications(agent),
apiCalls: this.checkAPIRequests(agent),
prActivity: this.checkPRActivity(agent),
terminalCommands: this.checkTerminalUsage(agent),

// Status inference
isActive: this.inferActiveStatus(agent),
currentTask: this.inferCurrentTask(agent),
blockages: this.detectBlockages(agent)
};
}
}
```

### 4. Work Item Tracking

#### Task Association
```javascript
class WorkTracker {
trackWork(entity) {
return {
currentWork: {
type: 'feature|bug|refactor|review',
description: 'Implementing user authentication',
source: 'issue#123|pr#456|direct_request',

files: [
{
path: 'src/auth.js',
status: 'modified',
changes: '+45 -12'
}
],

subtasks: [
{task: 'Setup routes', status: 'complete'},
{task: 'Add middleware', status: 'in_progress'},
{task: 'Write tests', status: 'pending'}
],

estimatedCompletion: '15 minutes',
startedAt: '2024-01-15T10:30:00Z',

dependencies: [
'database_migration_complete',
'api_endpoint_available'
]
}
};
}
}
```

### 5. Blocker Detection & Resolution

#### Intelligent Blocker Analysis
```javascript
class BlockerAnalyzer {
analyzeBlockers(agent) {
const blockers = [];

// Check for common blockers
if (this.hasMergeConflicts()) {
blockers.push({
type: 'merge_conflict',
severity: 'high',
files: this.getConflictedFiles(),
resolution: 'Manual merge required',
suggestedAction: this.generateMergeStrategy()
});
}

if (this.hasFailingTests()) {
blockers.push({
type: 'test_failure',
severity: 'medium',
tests: this.getFailingTests(),
resolution: 'Fix failing tests',
logs: this.getTestLogs()
});
}

if (this.isRateLimited()) {
blockers.push({
type: 'rate_limit',
severity: 'low',
service: 'GitHub API',
resetTime: this.getRateLimitReset(),
resolution: 'Wait or use different token'
});
}

return {
blockers,
canAutoResolve: this.checkAutoResolution(blockers),
estimatedResolutionTime: this.estimateResolution(blockers)
};
}
}
```

### 6. Collaboration Features

#### Inter-Agent Communication
```javascript
class AgentCollaboration {
coordinates() {
return {
// Prevent conflicts
fileLocking: {
acquire: (file, agent) => this.lockFile(file, agent),
release: (file, agent) => this.unlockFile(file, agent),
check: (file) => this.isFileLocked(file)
},

// Task delegation
taskQueue: {
assign: (task, agent) => this.assignTask(task, agent),
handoff: (task, fromAgent, toAgent) => this.handoffTask(),
split: (task) => this.splitTask(task)
},

// Communication
messaging: {
broadcast: (message) => this.broadcastToAgents(message),
direct: (agent, message) => this.sendToAgent(agent, message),
request: (agent, action) => this.requestAction(agent, action)
}
};
}
}
```

### 7. Performance Metrics

#### Agent Performance Tracking
```javascript
class PerformanceMetrics {
trackAgentMetrics(agent) {
return {
productivity: {
tasksCompleted: 15,
linesChanged: 450,
filesModified: 8,
prsCreated: 3,
issuesResolved: 5
},

efficiency: {
avgTaskTime: '12 minutes',
successRate: '92%',
reworkRate: '8%',
blockedTime: '5%'
},

quality: {
testsPassRate: '98%',
codeReviewScore: 4.5,
bugIntroduced: 0,
securityIssues: 0
},

collaboration: {
handoffsSmooth: 12,
conflictsCreated: 1,
assistanceProvided: 5
}
};
}
}
```

### 8. Notification System

#### Alert Configuration
```javascript
const alertRules = {
blocked: {
condition: 'agent.status === "blocked" && duration > 5min',
action: 'notify_user',
message: 'Agent {name} has been blocked for {duration}'
},

conflict: {
condition: 'multiple_agents_same_file',
action: 'warn_all_agents',
message: 'Potential conflict in {file}'
},

completed: {
condition: 'task.status === "complete"',
action: 'notify_stakeholders',
message: 'Task {task} completed by {agent}'
},

error: {
condition: 'agent.status === "error"',
action: 'alert_urgent',
message: 'Agent {name} encountered error: {error}'
}
};
```

### 9. Historical View

#### Activity Timeline
```
┌──────────────────────────────────────────────────────┐
│ 📊 Activity Timeline (Last 24 Hours) │
├──────────────────────────────────────────────────────┤
│ │
│ 09:00 ━━━━━●━━━━━━━━━━━━━━━━━━━━━━ 21:00 │
│ ▲ Claude started task │
│ ▲ Cursor joined │
│ ▲ Blocked on API │
│ ▲ Resolved, resumed │
│ ▲ Task completed │
│ │
│ Agent Uptime: │
│ Claude Code: ████████░░ 80% active │
│ Cursor: ██████░░░░ 60% active │
│ Devin: █████████░ 90% active │
│ │
└──────────────────────────────────────────────────────┘
```

### 10. Integration Points

#### Data Sources
- Git hooks for commit/push events
- File system watchers
- IDE/Editor plugins
- GitHub API webhooks
- Agent-specific APIs
- WebSocket connections
- Process monitoring

## UI Components

### Status Cards
```typescript
interface AgentStatusCard {
agent: {
name: string;
type: 'ai' | 'human';
avatar: string;
};

status: {
current: StatusType;
duration: string;
lastChange: Date;
};

activity: {
currentTask: string;
progress: number;
files: string[];
lastAction: string;
};

blockers?: {
type: string;
description: string;
suggestedFix: string;
}[];

actions: {
viewDetails: () => void;
sendMessage: () => void;
reassignTask: () => void;
resolveBlocker: () => void;
};
}
```

## Benefits

- **Visibility**: See who's working on what in real-time
- **Coordination**: Prevent conflicts between agents
- **Efficiency**: Quickly identify and resolve blockers
- **Accountability**: Track agent performance
- **Collaboration**: Better human-AI coordination
- **Debugging**: Understand what went wrong

## Acceptance Criteria

- [ ] All active agents are detected and displayed
- [ ] Status updates in real-time (< 5 second delay)
- [ ] Blockers are accurately identified
- [ ] Task progress is tracked correctly
- [ ] File locks prevent conflicts
- [ ] Historical data is preserved
- [ ] Notifications work as configured
- [ ] Performance metrics are accurate
- [ ] UI updates smoothly
- [ ] Multiple agent types supported
- [ ] Human users are tracked
- [ ] Integration with version control works
- [ ] Scalable to many agents

🤖 Generated with [Claude Code](https://claude.ai/code)

The issue does not name any repository files, tests, or entry points. Start by inspecting the Electron application's existing UI and integration structure, then narrow the broad dashboard proposal into a defined first milestone. Done requires agreed scope and tests for the selected status, update, tracking, and notification behavior.

Written by the indexing model from the issue text.