[P1] Implement LeadAgent.detect_bottlenecks() logic

[frankbria]

Overview

Bottleneck detection is critical for optimizing multi-agent workflows, but the method is currently stubbed.

Current State

File: codeframe/agents/lead_agent.py lines 594-596

def detect_bottlenecks(self) -> list:
    """Detect workflow bottlenecks."""
    # TODO: Implement bottleneck detection
    return []

Expected Behavior

Detect bottlenecks when:

• Tasks are waiting on dependencies longer than threshold
• Agents are idle while tasks are blocked
• Specific agents are overloaded with too many assignments
• Critical path tasks are delayed

Implementation Requirements

1. Query database for tasks with status='blocked' or 'waiting'
2. Calculate wait times for each blocked task
3. Identify agents with excessive workload (>5 tasks)
4. Identify idle agents (0 tasks assigned)
5. Detect dependency chain delays
6. Return list of bottleneck descriptors with severity

Return Format

[
    {
        "type": "dependency_wait",
        "task_id": 27,
        "wait_time_minutes": 120,
        "blocking_task_id": 25,
        "severity": "high"
    },
    {
        "type": "agent_overload",
        "agent_id": "backend-001",
        "assigned_tasks": 8,
        "severity": "medium"
    }
]

Acceptance Criteria

• Bottlenecks detected for dependency waits
• Bottlenecks detected for agent overload/underload
• Severity levels assigned correctly
• Recommendations provided for resolution
• Unit tests verify detection logic
• Integration tests verify bottleneck reporting

Priority

P1 - Critical: Required for efficient multi-agent coordination and preventing workflow stalls.

References

• User Documentation: CODEFRAME_USER_DOCUMENTATION.md lines 277-278
• Issues Analysis: CODEFRAME_ISSUES_ANALYSIS.md lines 31-38

[traycerai]

Plan

Observations

The detect_bottlenecks() method in file:codeframe/agents/lead_agent.py (lines 594-597) is currently stubbed. The codebase has robust infrastructure for multi-agent coordination including: database models with task statuses (PENDING, ASSIGNED, IN_PROGRESS, BLOCKED, COMPLETED, FAILED), agent pool management tracking agent workload and status, dependency resolution with DAG-based tracking, and blocker management with SYNC/ASYNC types. The existing _execute_coordination_loop() method demonstrates patterns for querying tasks and agents, while the DependencyResolver class provides methods for analyzing task dependencies and blocked tasks.

Approach

The implementation will leverage existing infrastructure to detect four types of bottlenecks: dependency waits (tasks blocked by incomplete dependencies), agent overload (agents with excessive task assignments), agent underutilization (idle agents while tasks are pending), and critical path delays (tasks blocking multiple dependents). The method will query the database for task and agent status, use the dependency resolver to identify blocking relationships, calculate wait times using task timestamps, and return structured bottleneck descriptors with severity levels (critical, high, medium, low) based on configurable thresholds. This approach aligns with the specifications in file:specs/CODEFRAME_SPEC.md and integrates seamlessly with the existing coordination loop.

Implementation Steps

1. Implement Core Bottleneck Detection Logic

Update the detect_bottlenecks() method in file:codeframe/agents/lead_agent.py (lines 594-597) to implement the detection algorithm:

Query Data Sources:

• Use self.db.get_project_tasks(self.project_id) to retrieve all tasks
• Use self.agent_pool_manager.get_agent_status() to get agent workload information
• Use self.db.list_blockers(project_id=self.project_id, status="PENDING") to get active blockers
• Use self.dependency_resolver.get_blocked_tasks() to identify dependency chains

Detection Categories:

a) Dependency Wait Bottlenecks:

• Iterate through tasks with status='blocked' or tasks waiting on dependencies
• For each blocked task, calculate wait time using created_at timestamp and current time
• Identify the blocking task(s) from the dependency resolver
• Create bottleneck descriptor if wait time exceeds threshold (e.g., 60 minutes)
• Severity: "critical" if >120 min, "high" if >60 min, "medium" if >30 min

b) Agent Overload Bottlenecks:

• Iterate through agent status from agent pool manager
• Count tasks assigned to each agent (status='busy' with current_task)
• Create bottleneck descriptor if agent has >5 assigned tasks
• Severity: "high" if >8 tasks, "medium" if >5 tasks

c) Agent Idle Bottlenecks:

• Identify agents with status='idle' and current_task=None
• Check if there are pending tasks (status='pending') available
• Create bottleneck descriptor if idle agents exist while tasks are pending
• Severity: "medium" (indicates suboptimal resource utilization)

d) Critical Path Bottlenecks:

• Use self.dependency_resolver.dependents to count how many tasks depend on each incomplete task
• Identify tasks blocking ≥3 dependent tasks (configurable threshold)
• Create bottleneck descriptor with count of blocked dependents
• Severity: "critical" if ≥5 dependents, "high" if ≥3 dependents

Return Format:
Return a list of dictionaries with the structure specified in the issue:

{
    "type": "dependency_wait" | "agent_overload" | "agent_idle" | "critical_path",
    "task_id": int (optional, for task-specific bottlenecks),
    "agent_id": str (optional, for agent-specific bottlenecks),
    "wait_time_minutes": int (for dependency_wait),
    "blocking_task_id": int (for dependency_wait),
    "assigned_tasks": int (for agent_overload),
    "idle_agents": list[str] (for agent_idle),
    "blocked_dependents": int (for critical_path),
    "severity": "critical" | "high" | "medium" | "low",
    "recommendation": str (actionable suggestion)
}

2. Add Configuration Constants

Add configurable thresholds at the top of the LeadAgent class or as class constants:

• DEPENDENCY_WAIT_THRESHOLD_MINUTES = 60 (when to flag dependency waits)
• AGENT_OVERLOAD_THRESHOLD = 5 (max tasks per agent before flagging)
• CRITICAL_PATH_THRESHOLD = 3 (min dependents to flag as bottleneck)
• CRITICAL_SEVERITY_WAIT_MINUTES = 120 (threshold for critical severity)
• HIGH_SEVERITY_WAIT_MINUTES = 60 (threshold for high severity)

3. Add Helper Methods

Create private helper methods to improve code organization:

_calculate_wait_time(task: dict) -> int:

• Calculate minutes elapsed since task entered blocked/waiting state
• Use created_at or updated_at timestamp from task dictionary
• Return wait time in minutes

_get_agent_workload() -> dict[str, int]:

• Query agent pool manager for all agents
• Count assigned tasks per agent
• Return mapping of agent_id to task count

_get_blocking_relationships() -> dict[int, list[int]]:

• Use dependency resolver to map blocked tasks to their blockers
• Return dictionary of task_id to list of blocking task_ids

_determine_severity(bottleneck_type: str, metrics: dict) -> str:

• Apply severity rules based on bottleneck type and metrics
• Return "critical", "high", "medium", or "low"

_generate_recommendation(bottleneck: dict) -> str:

• Generate actionable recommendation based on bottleneck type
• Examples:
  • dependency_wait: "Prioritize task {blocking_task_id} or reassign resources"
  • agent_overload: "Redistribute tasks or create additional agents"
  • agent_idle: "Assign pending tasks to idle agents"
  • critical_path: "Prioritize task {task_id} blocking {count} dependents"

4. Integration with Coordination Loop

The detect_bottlenecks() method should be callable from the coordination loop in _execute_coordination_loop():

• Can be called periodically (e.g., every N iterations) to monitor workflow health
• Results can be logged for visibility or used to trigger automatic optimizations
• Consider adding bottleneck detection before the main execution loop starts to identify issues early

5. Add Logging and Monitoring

Add comprehensive logging throughout the detection logic:

• Log when bottlenecks are detected with severity and details
• Log summary statistics (total bottlenecks by type and severity)
• Use appropriate log levels: WARNING for high/critical, INFO for medium/low
• Example: logger.warning(f"Critical bottleneck detected: {bottleneck['type']} - {bottleneck['recommendation']}")

6. Unit Tests

Create test file file:tests/agents/test_lead_agent_bottleneck_detection.py with comprehensive test coverage:

Test Cases:

a) Test Dependency Wait Detection:

• Create tasks with blocked status and old timestamps
• Verify bottleneck detected with correct wait time
• Verify severity levels based on wait duration
• Test with no blocked tasks (should return empty list)

b) Test Agent Overload Detection:

• Mock agent pool manager with agents having >5 tasks
• Verify bottleneck detected with correct task count
• Test with balanced workload (should not detect bottleneck)

c) Test Agent Idle Detection:

• Mock agent pool with idle agents and pending tasks
• Verify bottleneck detected with idle agent list
• Test with no idle agents (should not detect bottleneck)

d) Test Critical Path Detection:

• Build dependency graph with tasks blocking multiple dependents
• Verify bottleneck detected with correct dependent count
• Test with no critical path tasks (should return empty list)

e) Test Severity Calculation:

• Test boundary conditions for each severity level
• Verify correct severity assigned based on metrics

f) Test Multiple Bottlenecks:

• Create scenario with multiple bottleneck types simultaneously
• Verify all bottlenecks detected and returned

g) Test Empty State:

• Test with no tasks or agents
• Verify method returns empty list without errors

Test Fixtures:

• Use pytest fixtures to create mock database, agent pool manager, and dependency resolver
• Create helper functions to generate test tasks with various statuses and timestamps
• Mock datetime to control wait time calculations

7. Integration Tests

Add integration tests to file:tests/agents/test_multi_agent_integration.py:

Test Scenarios:

a) End-to-End Bottleneck Detection:

• Create real project with tasks and agents
• Simulate bottleneck conditions (blocked tasks, overloaded agents)
• Call detect_bottlenecks() and verify results
• Verify bottlenecks are actionable and accurate

b) Bottleneck Detection During Execution:

• Start multi-agent execution with intentional bottlenecks
• Call detect_bottlenecks() during execution
• Verify detection works with live coordination loop

c) Performance Testing:

• Test with large number of tasks (100+) and agents (10+)
• Verify detection completes in reasonable time (<1 second)
• Ensure no performance degradation in coordination loop

Architecture Diagram

sequenceDiagram
    participant LA as LeadAgent
    participant DB as Database
    participant APM as AgentPoolManager
    participant DR as DependencyResolver
    
    LA->>DB: get_project_tasks(project_id)
    DB-->>LA: List[Task]
    
    LA->>APM: get_agent_status()
    APM-->>LA: Dict[agent_id, status]
    
    LA->>DR: get_blocked_tasks()
    DR-->>LA: Dict[task_id, blockers]
    
    LA->>DB: list_blockers(status=PENDING)
    DB-->>LA: List[Blocker]
    
    LA->>LA: _calculate_wait_time(tasks)
    LA->>LA: _get_agent_workload(agents)
    LA->>LA: _get_blocking_relationships(deps)
    
    LA->>LA: Detect dependency_wait bottlenecks
    LA->>LA: Detect agent_overload bottlenecks
    LA->>LA: Detect agent_idle bottlenecks
    LA->>LA: Detect critical_path bottlenecks
    
    LA->>LA: _determine_severity(bottlenecks)
    LA->>LA: _generate_recommendation(bottlenecks)
    
    LA-->>LA: Return List[Bottleneck]

Loading

Bottleneck Detection Flow

flowchart TD
    A[detect_bottlenecks called] --> B[Query Tasks from DB]
    B --> C[Query Agent Status]
    C --> D[Query Dependency Graph]
    D --> E[Query Active Blockers]
    
    E --> F{Analyze Dependency Waits}
    F -->|Blocked tasks found| G[Calculate wait times]
    G -->|Wait > threshold| H[Create dependency_wait bottleneck]
    
    E --> I{Analyze Agent Workload}
    I -->|Agent has >5 tasks| J[Create agent_overload bottleneck]
    I -->|Idle agents + pending tasks| K[Create agent_idle bottleneck]
    
    E --> L{Analyze Critical Path}
    L -->|Task blocks ≥3 dependents| M[Create critical_path bottleneck]
    
    H --> N[Determine Severity]
    J --> N
    K --> N
    M --> N
    
    N --> O[Generate Recommendations]
    O --> P[Return Bottleneck List]

Loading

Bottleneck Types Summary

Type	Detection Criteria	Severity Rules	Recommendation
dependency_wait	Task blocked >60 min	Critical: >120 min High: >60 min Medium: >30 min	Prioritize blocking task or reassign resources
agent_overload	Agent has >5 tasks	High: >8 tasks Medium: >5 tasks	Redistribute tasks or create additional agents
agent_idle	Idle agents + pending tasks	Medium	Assign pending tasks to idle agents
critical_path	Task blocks ≥3 dependents	Critical: ≥5 dependents High: ≥3 dependents	Prioritize task to unblock dependents

Import In IDE

🤖 Prompt for AI Agents

## Observations

The `detect_bottlenecks()` method in `file:codeframe/agents/lead_agent.py` (lines 594-597) is currently stubbed. The codebase has robust infrastructure for multi-agent coordination including: database models with task statuses (PENDING, ASSIGNED, IN_PROGRESS, BLOCKED, COMPLETED, FAILED), agent pool management tracking agent workload and status, dependency resolution with DAG-based tracking, and blocker management with SYNC/ASYNC types. The existing `_execute_coordination_loop()` method demonstrates patterns for querying tasks and agents, while the `DependencyResolver` class provides methods for analyzing task dependencies and blocked tasks.

## Approach

The implementation will leverage existing infrastructure to detect four types of bottlenecks: dependency waits (tasks blocked by incomplete dependencies), agent overload (agents with excessive task assignments), agent underutilization (idle agents while tasks are pending), and critical path delays (tasks blocking multiple dependents). The method will query the database for task and agent status, use the dependency resolver to identify blocking relationships, calculate wait times using task timestamps, and return structured bottleneck descriptors with severity levels (critical, high, medium, low) based on configurable thresholds. This approach aligns with the specifications in `file:specs/CODEFRAME_SPEC.md` and integrates seamlessly with the existing coordination loop.

## Implementation Steps

### 1. Implement Core Bottleneck Detection Logic

Update the `detect_bottlenecks()` method in `file:codeframe/agents/lead_agent.py` (lines 594-597) to implement the detection algorithm:

**Query Data Sources:**
- Use `self.db.get_project_tasks(self.project_id)` to retrieve all tasks
- Use `self.agent_pool_manager.get_agent_status()` to get agent workload information
- Use `self.db.list_blockers(project_id=self.project_id, status="PENDING")` to get active blockers
- Use `self.dependency_resolver.get_blocked_tasks()` to identify dependency chains

**Detection Categories:**

a) **Dependency Wait Bottlenecks:**
- Iterate through tasks with status='blocked' or tasks waiting on dependencies
- For each blocked task, calculate wait time using `created_at` timestamp and current time
- Identify the blocking task(s) from the dependency resolver
- Create bottleneck descriptor if wait time exceeds threshold (e.g., 60 minutes)
- Severity: "critical" if >120 min, "high" if >60 min, "medium" if >30 min

b) **Agent Overload Bottlenecks:**
- Iterate through agent status from agent pool manager
- Count tasks assigned to each agent (status='busy' with current_task)
- Create bottleneck descriptor if agent has >5 assigned tasks
- Severity: "high" if >8 tasks, "medium" if >5 tasks

c) **Agent Idle Bottlenecks:**
- Identify agents with status='idle' and current_task=None
- Check if there are pending tasks (status='pending') available
- Create bottleneck descriptor if idle agents exist while tasks are pending
- Severity: "medium" (indicates suboptimal resource utilization)

d) **Critical Path Bottlenecks:**
- Use `self.dependency_resolver.dependents` to count how many tasks depend on each incomplete task
- Identify tasks blocking ≥3 dependent tasks (configurable threshold)
- Create bottleneck descriptor with count of blocked dependents
- Severity: "critical" if ≥5 dependents, "high" if ≥3 dependents

**Return Format:**
Return a list of dictionaries with the structure specified in the issue:
```python
{
    "type": "dependency_wait" | "agent_overload" | "agent_idle" | "critical_path",
    "task_id": int (optional, for task-specific bottlenecks),
    "agent_id": str (optional, for agent-specific bottlenecks),
    "wait_time_minutes": int (for dependency_wait),
    "blocking_task_id": int (for dependency_wait),
    "assigned_tasks": int (for agent_overload),
    "idle_agents": list[str] (for agent_idle),
    "blocked_dependents": int (for critical_path),
    "severity": "critical" | "high" | "medium" | "low",
    "recommendation": str (actionable suggestion)
}
```

### 2. Add Configuration Constants

Add configurable thresholds at the top of the `LeadAgent` class or as class constants:
- `DEPENDENCY_WAIT_THRESHOLD_MINUTES = 60` (when to flag dependency waits)
- `AGENT_OVERLOAD_THRESHOLD = 5` (max tasks per agent before flagging)
- `CRITICAL_PATH_THRESHOLD = 3` (min dependents to flag as bottleneck)
- `CRITICAL_SEVERITY_WAIT_MINUTES = 120` (threshold for critical severity)
- `HIGH_SEVERITY_WAIT_MINUTES = 60` (threshold for high severity)

### 3. Add Helper Methods

Create private helper methods to improve code organization:

**`_calculate_wait_time(task: dict) -> int`:**
- Calculate minutes elapsed since task entered blocked/waiting state
- Use `created_at` or `updated_at` timestamp from task dictionary
- Return wait time in minutes

**`_get_agent_workload() -> dict[str, int]`:**
- Query agent pool manager for all agents
- Count assigned tasks per agent
- Return mapping of agent_id to task count

**`_get_blocking_relationships() -> dict[int, list[int]]`:**
- Use dependency resolver to map blocked tasks to their blockers
- Return dictionary of task_id to list of blocking task_ids

**`_determine_severity(bottleneck_type: str, metrics: dict) -> str`:**
- Apply severity rules based on bottleneck type and metrics
- Return "critical", "high", "medium", or "low"

**`_generate_recommendation(bottleneck: dict) -> str`:**
- Generate actionable recommendation based on bottleneck type
- Examples:
  - dependency_wait: "Prioritize task {blocking_task_id} or reassign resources"
  - agent_overload: "Redistribute tasks or create additional agents"
  - agent_idle: "Assign pending tasks to idle agents"
  - critical_path: "Prioritize task {task_id} blocking {count} dependents"

### 4. Integration with Coordination Loop

The `detect_bottlenecks()` method should be callable from the coordination loop in `_execute_coordination_loop()`:
- Can be called periodically (e.g., every N iterations) to monitor workflow health
- Results can be logged for visibility or used to trigger automatic optimizations
- Consider adding bottleneck detection before the main execution loop starts to identify issues early

### 5. Add Logging and Monitoring

Add comprehensive logging throughout the detection logic:
- Log when bottlenecks are detected with severity and details
- Log summary statistics (total bottlenecks by type and severity)
- Use appropriate log levels: WARNING for high/critical, INFO for medium/low
- Example: `logger.warning(f"Critical bottleneck detected: {bottleneck['type']} - {bottleneck['recommendation']}")`

### 6. Unit Tests

Create test file `file:tests/agents/test_lead_agent_bottleneck_detection.py` with comprehensive test coverage:

**Test Cases:**

a) **Test Dependency Wait Detection:**
- Create tasks with blocked status and old timestamps
- Verify bottleneck detected with correct wait time
- Verify severity levels based on wait duration
- Test with no blocked tasks (should return empty list)

b) **Test Agent Overload Detection:**
- Mock agent pool manager with agents having >5 tasks
- Verify bottleneck detected with correct task count
- Test with balanced workload (should not detect bottleneck)

c) **Test Agent Idle Detection:**
- Mock agent pool with idle agents and pending tasks
- Verify bottleneck detected with idle agent list
- Test with no idle agents (should not detect bottleneck)

d) **Test Critical Path Detection:**
- Build dependency graph with tasks blocking multiple dependents
- Verify bottleneck detected with correct dependent count
- Test with no critical path tasks (should return empty list)

e) **Test Severity Calculation:**
- Test boundary conditions for each severity level
- Verify correct severity assigned based on metrics

f) **Test Multiple Bottlenecks:**
- Create scenario with multiple bottleneck types simultaneously
- Verify all bottlenecks detected and returned

g) **Test Empty State:**
- Test with no tasks or agents
- Verify method returns empty list without errors

**Test Fixtures:**
- Use pytest fixtures to create mock database, agent pool manager, and dependency resolver
- Create helper functions to generate test tasks with various statuses and timestamps
- Mock datetime to control wait time calculations

### 7. Integration Tests

Add integration tests to `file:tests/agents/test_multi_agent_integration.py`:

**Test Scenarios:**

a) **End-to-End Bottleneck Detection:**
- Create real project with tasks and agents
- Simulate bottleneck conditions (blocked tasks, overloaded agents)
- Call `detect_bottlenecks()` and verify results
- Verify bottlenecks are actionable and accurate

b) **Bottleneck Detection During Execution:**
- Start multi-agent execution with intentional bottlenecks
- Call `detect_bottlenecks()` during execution
- Verify detection works with live coordination loop

c) **Performance Testing:**
- Test with large number of tasks (100+) and agents (10+)
- Verify detection completes in reasonable time (<1 second)
- Ensure no performance degradation in coordination loop

## Architecture Diagram

```mermaid
sequenceDiagram
    participant LA as LeadAgent
    participant DB as Database
    participant APM as AgentPoolManager
    participant DR as DependencyResolver
    
    LA->>DB: get_project_tasks(project_id)
    DB-->>LA: List[Task]
    
    LA->>APM: get_agent_status()
    APM-->>LA: Dict[agent_id, status]
    
    LA->>DR: get_blocked_tasks()
    DR-->>LA: Dict[task_id, blockers]
    
    LA->>DB: list_blockers(status=PENDING)
    DB-->>LA: List[Blocker]
    
    LA->>LA: _calculate_wait_time(tasks)
    LA->>LA: _get_agent_workload(agents)
    LA->>LA: _get_blocking_relationships(deps)
    
    LA->>LA: Detect dependency_wait bottlenecks
    LA->>LA: Detect agent_overload bottlenecks
    LA->>LA: Detect agent_idle bottlenecks
    LA->>LA: Detect critical_path bottlenecks
    
    LA->>LA: _determine_severity(bottlenecks)
    LA->>LA: _generate_recommendation(bottlenecks)
    
    LA-->>LA: Return List[Bottleneck]
```

## Bottleneck Detection Flow

```mermaid
flowchart TD
    A[detect_bottlenecks called] --> B[Query Tasks from DB]
    B --> C[Query Agent Status]
    C --> D[Query Dependency Graph]
    D --> E[Query Active Blockers]
    
    E --> F{Analyze Dependency Waits}
    F -->|Blocked tasks found| G[Calculate wait times]
    G -->|Wait > threshold| H[Create dependency_wait bottleneck]
    
    E --> I{Analyze Agent Workload}
    I -->|Agent has >5 tasks| J[Create agent_overload bottleneck]
    I -->|Idle agents + pending tasks| K[Create agent_idle bottleneck]
    
    E --> L{Analyze Critical Path}
    L -->|Task blocks ≥3 dependents| M[Create critical_path bottleneck]
    
    H --> N[Determine Severity]
    J --> N
    K --> N
    M --> N
    
    N --> O[Generate Recommendations]
    O --> P[Return Bottleneck List]
```

## Bottleneck Types Summary

| Type | Detection Criteria | Severity Rules | Recommendation |
|------|-------------------|----------------|----------------|
| **dependency_wait** | Task blocked >60 min | Critical: >120 min<br>High: >60 min<br>Medium: >30 min | Prioritize blocking task or reassign resources |
| **agent_overload** | Agent has >5 tasks | High: >8 tasks<br>Medium: >5 tasks | Redistribute tasks or create additional agents |
| **agent_idle** | Idle agents + pending tasks | Medium | Assign pending tasks to idle agents |
| **critical_path** | Task blocks ≥3 dependents | Critical: ≥5 dependents<br>High: ≥3 dependents | Prioritize task to unblock dependents |

---

Execution Information

Branch: main
Commit: 1a87e4e

---

💡 Tips

Supported Commands (Inside Comments)

• Use @traycerai generate to iterate on the previous version of the implementation plan.

Supported Commands (Inside Description)

• Add @traycerai ignore anywhere in the ticket description to prevent this ticket from being processed.
• Add @traycerai branch:<branch-name> anywhere in the ticket description to specify the target branch for the implementation plan.

Community

• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[coderabbitai]

📝 CodeRabbit Plan Mode

Generate an implementation plan and prompts that you can use with your favorite coding agent.

• Create Plan

Examples

• Example 1
• Example 2

_{You can configure auto-planning by selecting labels in the issue_enrichment configuration.}

🔗 Similar Issues

Related Issues

• [P1] Implement LeadAgent.assign_task() logic #100
• [P1] Implement WorkerAgent.execute_task() with Anthropic API integration #98
• [P1] Add token tracking after LLM calls in WorkerAgent #99
• [Future] Implement Goal Recitation for Long-Running Tasks #70
• [Phase 4] Replace Fixed Self-Correction Cap with Adaptive Failure Handling #71

🔗 Related PRs

#18 - feat(049-human-in-loop): Complete human-in-the-loop blocker system (Phases 1-9) [merged]

👤 Suggested Assignees

• frankbria

---

🧪 Issue enrichment is currently in open beta.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord or schedule a call!