from utils.kb_manager import initialize_kb

# Initialize KB if this is first use
if not verify_kb_exists():
    initialize_kb()

# Invoke code-reviewer for pre-planning cleanup
cleanup_result = await invoke_specialist(
    specialist='code-reviewer',
    task='Pre-planning cleanup: scan for dead/stale code'
)

# Present cleanup findings to user for approval
if cleanup_result['issues_found']:
    present_cleanup_report(cleanup_result)
    await wait_for_user_approval()

from utils.auto_planner import auto_plan_feature

# Auto-generate plan by consulting specialists
plan = await auto_plan_feature(
    feature_description=user_input,
    user_hints=parse_user_hints(user_input)
)

# Present plan to user for approval
present_plan(plan)
user_approved = await wait_for_user_approval()

if not user_approved:
    # User wants to modify plan
    plan = await modify_plan_with_user_input(plan)

from utils.parallel_executor import execute_plan_parallel
from utils.checkpoint_validator import run_checkpoint
from utils.error_recovery import handle_task_failure

# Execute plan with parallel orchestration
try:
    updated_plan = await execute_plan_parallel(plan)

    # Present completion summary
    present_completion_summary(updated_plan)

except Exception as e:
    # Handle plan-level failures
    handle_plan_failure(plan, e)

# Show user what was accomplished
summary = {
    'tasks_completed': count_completed_tasks(plan),
    'kb_updates': collect_kb_updates(plan),
    'workspace_files': collect_workspace_files(plan)
}

present_summary(summary)

# Offer workspace cleanup
if await ask_user("Clean up workspace files?"):
    cleanup_workspace()

User: /dev-team "Add user authentication with JWT"

Coordinator:
→ Phase 1: Code Reviewer scans for dead code
  → Finds 3 unused imports in auth.py
  → User approves cleanup

→ Phase 2: Auto-planning
  → Consults backend-architect, fastapi-specialist, backend-design, docker-specialist
  → Synthesizes plan with 5 tasks
  → User approves plan

→ Phase 3: Parallel execution
  → Task 1 (backend-architect): Design auth flow
    → Checkpoint passed
  → Task 2 (backend-design): Design API schemas
  → Task 3 (fastapi-specialist): Implement /auth/login
    → Runs in parallel with Task 2
    → Checkpoint passed
  → Task 4 (code-reviewer): Review and simplify
    → Checkpoint passed
  → Task 5 (docker-specialist): Update container config
    → Checkpoint passed

→ Phase 4: Completion
  → Summary: 5 tasks completed, KB updated, 5 workspace files created
  → User approves workspace cleanup
  → Session complete

Task 3 (fastapi-specialist) fails: "Design unclear about token storage"

Coordinator:
→ Classifies as FIXABLE failure
→ Loops back to Task 1 (backend-architect)
→ Gets clarification: "Store tokens in Redis with TTL"
→ Updates work/auth-design.md with clarification
→ Retries Task 3
→ Task 3 succeeds on retry
→ Continues execution

# Core utilities
from utils.kb_manager import (
    initialize_kb,
    verify_kb_exists,
    log_decision
)
from utils.dag_parser import (
    parse_task_list,
    get_ready_tasks,
    update_task_status
)

# Auto-planning
from utils.auto_planner import (
    auto_plan_feature,
    parse_user_hints,
    modify_plan_with_user_input
)

# Execution
from utils.parallel_executor import (
    execute_plan_parallel,
    execute_task_batch
)

# Validation and recovery
from utils.checkpoint_validator import (
    run_checkpoint,
    validate_task_output,
    peer_review_task
)
from utils.error_recovery import (
    handle_task_failure,
    classify_failure,
    attempt_recovery
)

# Reporting
def present_cleanup_report(cleanup_result):
    """Show cleanup findings to user."""
    pass

def present_plan(plan):
    """Show plan to user for approval."""
    pass

def present_completion_summary(plan):
    """Show final summary of work completed."""
    pass

def count_completed_tasks(plan):
    """Count successfully completed tasks."""
    return sum(1 for t in plan['tasks'].values() if t['status'] == 'completed')

def collect_kb_updates(plan):
    """Collect all KB updates made during execution."""
    return [t.get('kb_updates', []) for t in plan['tasks'].values()]

def collect_workspace_files(plan):
    """Collect all workspace files created."""
    return [t.get('workspace_files', []) for t in plan['tasks'].values()]

def cleanup_workspace():
    """Clean up temporary workspace files."""
    pass

async def wait_for_user_approval():
    """Wait for user to approve/reject."""
    pass

async def ask_user(question):
    """Ask user a yes/no question."""
    pass

async def invoke_specialist(specialist, task):
    """Invoke a specialist to complete a task."""
    pass