Projector v2.0 — Процедуры и алгоритмы

# Шаг 1.1: Получение запроса (30 сек)
user_request = orchestrator.receive_message(user_id)

# Шаг 1.2: Активация Projector (1 мин)
projector = orchestrator.activate_agent(
    "Projector",
    user_request,
    {"mode": "START"}
)

# Шаг 1.3: Автоопределение типа проекта (2 мин)
project_type = projector.detect_project_type(user_request)
# Результат: {"type": "TECH", "confidence": 0.85}

# Шаг 1.4: Определение уровня (1.5 мин)
if project_type["confidence"] > 0.8:
    project_level = projector.detect_project_level(user_request)
    # Результат: {"level": "B", "confidence": 0.78}
else:
    # LOW CONFIDENCE → уточнить у пользователя
    project_type = projector.ask_user_for_type()
    project_level = projector.ask_user_for_level()

# Шаг 1.5: Выбор ассистента (30 сек)
specialist = projector.select_specialist(project_type["type"])
# specialist = "Technical Assistant"

✅ Определён тип проекта: TECH (техническая система)
✅ Определён уровень: B (тактический, 3-12 мес, 5-20 чел)
✅ Назначен специалист: Technical Assistant

Начинаем сбор данных...

# Шаг 2.1: Определение набора вопросов (1 мин)
questions = specialist.get_questions_for_level(project_level["level"])
# Для уровня B (Technical): 20 вопросов * 60% = 12 вопросов

# Шаг 2.2: Интерактивный опрос (15 мин)
collected_data = {}
for question in questions:
    answer = projector.ask_user(question)
    collected_data[question.id] = answer

    # Валидация на лету
    if not specialist.validate_answer(answer, question):
        answer = projector.ask_user(question, retry=True)

# Шаг 2.3: Проверка constraints и зависимостей (3 мин)
constraints = specialist.extract_constraints(collected_data)
dependencies = specialist.identify_dependencies(collected_data)

# Шаг 2.4: Валидация полноты данных (2 мин)
validation = specialist.validate_data_collection({
    "data": collected_data,
    "constraints": constraints,
    "dependencies": dependencies
})

# Шаг 2.5: Светофорная проверка (1 мин)
traffic_light = projector.calculate_stage_status(validation)

if traffic_light == "RED":
    # БЛОКИРОВКА → запросить недостающие данные
    missing = specialist.get_missing_critical_data(collected_data)
    for field in missing:
        collected_data[field] = projector.ask_user(field)

📋 СБОР ДАННЫХ (Вопросов: 12/20 для уровня B)

1/12: Какая основная цель системы?
      → Ответ: "CRM для управления клиентами"

2/12: Какие основные функции требуются?
      → Ответ: "Контакты, задачи, сделки, отчёты"

...

12/12: Какие интеграции нужны?
       → Ответ: "Email, телефония, 1С"

✅ ВАЛИДАЦИЯ: Все критичные данные собраны
🟢 СТАТУС ЭТАПА: ЗЕЛЁНЫЙ (100% готовность)

Переходим к исследованиям...

# Шаг 3.1: Делегирование исследования ассистенту (1 мин)
research_task = projector.delegate_to_specialist(
    specialist=specialist,
    stage="research",
    data=collected_data
)

# Шаг 3.2: Specialist проводит исследование (10 мин)
research_result = specialist.conduct_research({
    "generate_hypotheses": True,      # 3+ гипотезы
    "competitive_analysis": True,     # 3+ конкурента
    "explore_alternatives": True,     # 3+ альтернативы
    "market_research": True           # Если BUSINESS/MARKETING
})

# Шаг 3.3: Projector получает результат (30 сек)
hypotheses = research_result["hypotheses"]          # Список из 3-5 гипотез
competitors = research_result["competitors"]        # Список конкурентов
alternatives = research_result["alternatives"]      # Build/Buy/SaaS/etc

# Шаг 3.4: Валидация исследования (2 мин)
validation = specialist.validate_research({
    "hypotheses_count": len(hypotheses) >= 3,
    "competitors_analyzed": len(competitors) >= 3,
    "alternatives_count": len(alternatives) >= 3,
    "report_exists": research_result["report"] is not None
})

# Шаг 3.5: Светофорная проверка (1 мин)
traffic_light = projector.calculate_stage_status(validation)

🔍 ИССЛЕДОВАНИЯ (Technical Assistant)

Гипотезы (5):
1. Разработка с нуля займёт 6 месяцев
2. SaaS решение сократит время до 2 недель
3. Интеграция с 1С критична для принятия
4. Команда 10 человек оптимальна
5. Cloud-native архитектура снизит TCO на 30%

Конкуренты (4):
- Битрикс24 (лидер, высокая цена)
- amoCRM (простота, ограниченность)
- Salesforce (enterprise, сложность)
- Мегаплан (российский, интеграции)

Альтернативы (3):
A. Разработка с нуля (контроль, время 6 мес, $500K)
B. SaaS Битрикс24 (быстро, зависимость, $50K/год)
C. Open Source + кастомизация (гибкость, 3 мес, $200K)

✅ ВАЛИДАЦИЯ: Все критерии выполнены
🟢 СТАТУС ЭТАПА: ЗЕЛЁНЫЙ

Переходим к аналитике...

# Шаг 4.1: Делегирование аналитики (1 мин)
analytics_task = projector.delegate_to_specialist(
    specialist=specialist,
    stage="analytics",
    data={
        "collected_data": collected_data,
        "research_result": research_result
    }
)

# Шаг 4.2: Specialist проводит аналитику (12 мин)
analytics_result = specialist.conduct_analytics({
    "calculate_roi": True,              # ROI для каждой альтернативы
    "assess_risks": True,               # Классификация рисков
    "build_financial_model": True,      # Затраты, сроки, окупаемость
    "generate_recommendations": True     # Топ рекомендация
})

# Шаг 4.3: Projector получает и структурирует (2 мин)
roi_analysis = analytics_result["roi"]
risk_matrix = analytics_result["risks"]
financial_model = analytics_result["financial"]
recommendation = analytics_result["recommendation"]

# Шаг 4.4: Валидация аналитики (3 мин)
validation = specialist.validate_analytics({
    "roi_calculated": roi_analysis is not None,
    "risks_categorized": len(risk_matrix) > 0,
    "financial_model_complete": financial_model["complete"],
    "recommendation_justified": recommendation["justification"] is not None
})

# Шаг 4.5: Светофорная проверка (1 мин)
traffic_light = projector.calculate_stage_status(validation)

📊 АНАЛИТИКА (Technical Assistant)

ROI Анализ:
┌─────────────────┬─────────┬─────────┬─────────┬────────┐
│ Альтернатива    │ Затраты │ Срок    │ ROI     │ Риски  │
├─────────────────┼─────────┼─────────┼─────────┼────────┤
│ A. С нуля       │ $500K   │ 6 мес   │ 180%    │ Высокие│
│ B. SaaS         │ $50K/г  │ 2 нед   │ 250%    │ Средние│
│ C. Open Source  │ $200K   │ 3 мес   │ 220%    │ Средние│
└─────────────────┴─────────┴─────────┴─────────┴────────┘

Риски (6):
🔴 ВЫСОКИЕ:
- Срыв сроков (вероятность 40%, влияние критическое)

🟡 СРЕДНИЕ:
- Проблемы интеграции с 1С (вероятность 30%)
- Недостаток ресурсов (вероятность 25%)

🟢 НИЗКИЕ:
- Проблемы с производительностью (5%)
- Отказ пользователей от миграции (10%)
- Проблемы безопасности (15%)

Финансовая модель:
- Инвестиции: $200K (Open Source вариант)
- Операционные: $30K/год
- Окупаемость: 14 месяцев
- NPV (3 года): $450K
- IRR: 85%

✅ РЕКОМЕНДАЦИЯ: Open Source + кастомизация
   Обоснование:
   - Оптимальный баланс время/затраты/контроль
   - Высокий ROI (220%)
   - Управляемые риски
   - Гибкость для кастомизаций

🟢 СТАТУС ЭТАПА: ЗЕЛЁНЫЙ

Переходим к проектированию...

# Шаг 5.1: Делегирование проектирования (1 мин)
design_task = projector.delegate_to_specialist(
    specialist=specialist,
    stage="design",
    data={
        "collected_data": collected_data,
        "research_result": research_result,
        "analytics_result": analytics_result,
        "chosen_alternative": recommendation["alternative"]
    }
)

# Шаг 5.2: Specialist создаёт детальный проект (12 мин)
design_result = specialist.conduct_design({
    "define_scope": True,               # Чёткий scope с границами
    "create_wbs": True,                 # Work Breakdown Structure
    "build_timeline": True,             # Timeline с зависимостями
    "allocate_resources": True,         # Команда, бюджет
    "identify_milestones": True         # Ключевые вехи
})

# Шаг 5.3: Projector структурирует проект (3 мин)
scope = design_result["scope"]
wbs = design_result["wbs"]
timeline = design_result["timeline"]
resources = design_result["resources"]
milestones = design_result["milestones"]

# Шаг 5.4: Валидация проектирования (3 мин)
validation = specialist.validate_design({
    "scope_clear": scope["clarity_score"] > 0.8,
    "wbs_complete": wbs["completeness"] > 0.9,
    "timeline_realistic": timeline["realistic"],
    "resources_allocated": resources["allocated"],
    "approval_obtained": False  # Будет получено от пользователя
})

# Шаг 5.5: Запрос одобрения у пользователя (1 мин + время пользователя)
approval = projector.request_user_approval({
    "scope": scope,
    "timeline": timeline,
    "budget": resources["budget"]
})

validation["approval_obtained"] = approval

# Шаг 5.6: Светофорная проверка (1 мин)
traffic_light = projector.calculate_stage_status(validation)

🎨 ПРОЕКТИРОВАНИЕ (Technical Assistant)

SCOPE:
├─ Основной функционал:
│  ├─ Управление контактами (CRM core)
│  ├─ Управление сделками (Sales pipeline)
│  ├─ Задачи и напоминания
│  ├─ Отчёты и аналитика
│  └─ Интеграция с 1С, Email, Телефония
│
├─ НЕ включено (out of scope):
│  ├─ Мобильное приложение (v2.0)
│  ├─ AI рекомендации (v2.0)
│  └─ Маркетинговая автоматизация (v3.0)

WBS (Work Breakdown Structure):
1. ПОДГОТОВКА (2 недели)
   1.1 Формирование команды
   1.2 Настройка инфраструктуры
   1.3 Выбор Open Source базы

2. РАЗРАБОТКА (10 недель)
   2.1 Backend API (4 недели)
   2.2 Frontend UI (4 недели)
   2.3 Интеграции (2 недели)

3. ТЕСТИРОВАНИЕ (2 недели)
   3.1 Unit tests
   3.2 Integration tests
   3.3 UAT

4. ДЕПЛОЙ (1 неделя)
   4.1 Production setup
   4.2 Data migration
   4.3 Go-live

TIMELINE:
├─ Старт: 2025-11-15
├─ Milestone 1: Backend API готов (2025-12-20)
├─ Milestone 2: MVP UI готов (2026-01-17)
├─ Milestone 3: Интеграции работают (2026-01-31)
├─ Milestone 4: UAT завершён (2026-02-14)
└─ Go-Live: 2026-02-21 (3 месяца от старта)

РЕСУРСЫ:
├─ Команда: 8 человек
│  ├─ Tech Lead (1)
│  ├─ Backend Dev (2)
│  ├─ Frontend Dev (2)
│  ├─ QA (1)
│  ├─ DevOps (1)
│  └─ BA/PM (1)
│
└─ Бюджет: $200K
   ├─ Зарплаты: $160K
   ├─ Инфраструктура: $20K
   └─ Лицензии: $20K

⚠️ ТРЕБУЕТСЯ ВАШЕ ОДОБРЕНИЕ:
   Согласны с scope, timeline, бюджетом? [да/нет/изменить]

✅ ОДОБРЕНИЕ ПОЛУЧЕНО
🟢 СТАТУС ЭТАПА: ЗЕЛЁНЫЙ

Генерируем документы...

# Шаг 6.1: Projector генерирует PROJECT.md (3 мин)
project_md = projector.generate_project_md({
    "project_id": "PRJ-2025-001-TECH-B",
    "type": project_type,
    "level": project_level,
    "goal": collected_data["goal"],
    "stages": {
        "data_collection": {"status": "completed", "traffic_light": "GREEN"},
        "research": {"status": "completed", "traffic_light": "GREEN"},
        "analytics": {"status": "completed", "traffic_light": "GREEN"},
        "design": {"status": "completed", "traffic_light": "GREEN"},
        "execution": {"status": "pending"}
    },
    "timeline": timeline,
    "risks": risk_matrix,
    "budget": resources["budget"]
})

# Шаг 6.2: Specialist генерирует TECHNICAL_SPEC.md (5 мин)
technical_spec = specialist.generate_specialist_document({
    "project_id": "PRJ-2025-001-TECH-B",
    "collected_data": collected_data,
    "research": research_result,
    "analytics": analytics_result,
    "design": design_result,
    "template": "TECHNICAL_SPEC"
})

# Шаг 6.3: Сохранение документов (1 мин)
project_path = f"projects/PRJ-2025-001-TECH-B/"
projector.save_document(project_md, f"{project_path}/PROJECT.md")
specialist.save_document(technical_spec, f"{project_path}/TECHNICAL_SPEC.md")

# Шаг 6.4: Регистрация в реестре (30 сек)
projector.register_project({
    "id": "PRJ-2025-001-TECH-B",
    "type": "TECH",
    "level": "B",
    "status": "READY_FOR_EXECUTION",
    "created": datetime.now(),
    "documents": [
        "PROJECT.md",
        "TECHNICAL_SPEC.md"
    ]
})

# Шаг 6.5: Переход в WORK MODE (30 сек)
projector.switch_mode("WORK")

📄 ДОКУМЕНТЫ СОЗДАНЫ

1. PROJECT.md (универсальный)
   ✅ ID проекта: PRJ-2025-001-TECH-B
   ✅ Цель и метрики
   ✅ Этапы с статусами (4/5 завершены)
   ✅ Риски и зависимости
   ✅ Timeline и бюджет

2. TECHNICAL_SPEC.md (специализированный)
   ✅ Техническая архитектура
   ✅ Стек технологий
   ✅ API спецификация
   ✅ Инфраструктура
   ✅ План разработки

🎉 ПРОЕКТ ГОТОВ К ИСПОЛНЕНИЮ!

Переход в WORK MODE...

Доступные команды:
- /status — статус проекта
- /next — следующие задачи
- /stage — контроль этапа
- /report — генерация отчёта

# Шаг 1.1: Получение project_id (30 сек)
project_id = projector.identify_project_from_request(user_request)
# "PRJ-2025-001-TECH-B" или "проект CRM"

# Шаг 1.2: Загрузка PROJECT.md (1 мин)
project_data = projector.load_project(project_id)

# Шаг 1.3: Проверка статусов этапов (1 мин)
current_stage = project_data["current_stage"]  # "execution"
stage_status = project_data["stages"][current_stage]["status"]

# Шаг 1.4: Проверка блокировок (30 сек)
blockers = projector.check_blockers(project_id)

📋 ДИАГНОСТИКА: PRJ-2025-001-TECH-B (CRM система)

СТАТУС:
├─ Текущий этап: ИСПОЛНЕНИЕ (5/5)
├─ Прогресс: 40% (4 из 10 недель)
└─ Светофор: 🟢 ЗЕЛЁНЫЙ

ЭТАПЫ:
✅ Сбор данных: ЗАВЕРШЁН
✅ Исследования: ЗАВЕРШЁН
✅ Аналитика: ЗАВЕРШЁН
✅ Проектирование: ЗАВЕРШЁН
🔵 Исполнение: В РАБОТЕ (40%)

МЕТРИКИ:
├─ Timeline: В срок (4/10 недель, запас 1 неделя)
├─ Бюджет: $80K из $200K потрачено (40%)
└─ Качество: 95% тестов проходит

БЛОКИРОВКИ: Нет

Что вы хотите сделать?
1. /status — детальный статус
2. /next — следующие задачи
3. /report — отчёт о прогрессе
4. Другое

# Шаг 2.1: Сборка полного статуса (2 мин)
status_report = projector.generate_status_report(project_id)

# Включает:
# - Общие метрики
# - Детализация по этапам
# - Команда и ресурсы
# - Риски
# - Ближайшие задачи

📊 СТАТУС ПРОЕКТА: PRJ-2025-001-TECH-B

═══════════════════════════════════════════════════

🎯 ЦЕЛЬ:
CRM система для управления клиентами и сделками

📅 TIMELINE:
├─ Старт: 2025-11-15
├─ Текущая дата: 2025-12-13 (4 недели)
├─ Go-Live: 2026-02-21
└─ Осталось: 10 недель

💰 БЮДЖЕТ:
├─ Выделено: $200K
├─ Потрачено: $80K (40%)
├─ Осталось: $120K
└─ Прогноз: $195K (в рамках бюджета)

📈 ПРОГРЕСС ПО ЭТАПАМ:
1. ✅ Сбор данных: 100% (2025-11-20)
2. ✅ Исследования: 100% (2025-11-25)
3. ✅ Аналитика: 100% (2025-11-30)
4. ✅ Проектирование: 100% (2025-12-05)
5. 🔵 Исполнение: 40% (в работе)
   ├─ Backend API: 70% ✅ (почти готов)
   ├─ Frontend UI: 30% ⚠️ (отстаём на 5%)
   └─ Интеграции: 0% (не начато)

👥 КОМАНДА (8 человек):
✅ Tech Lead: Иван П.
✅ Backend Dev: Мария С., Алексей К.
⚠️ Frontend Dev: Дмитрий Л. (болен), Ольга В.
✅ QA: Елена Т.
✅ DevOps: Сергей Б.
✅ BA/PM: Наталья Р.

🚨 РИСКИ:
🟡 Frontend отстаёт (5%) из-за болезни Дмитрия
   Митигация: Привлечь contractor на 2 недели

🟢 Остальные риски под контролем

✅ БЛОКИРОВКИ: Нет

🎯 СЛЕДУЮЩИЕ ЗАДАЧИ:
1. Завершить Backend API (осталось 2 дня)
2. Ускорить Frontend разработку
3. Подготовиться к интеграциям (старт на след неделе)

═══════════════════════════════════════════════════

# Шаг 3.1: Анализ текущего состояния (1 мин)
current_tasks = projector.get_current_tasks(project_id)
completed = [t for t in current_tasks if t.status == "done"]
in_progress = [t for t in current_tasks if t.status == "in_progress"]
pending = [t for t in current_tasks if t.status == "pending"]

# Шаг 3.2: Определение следующих задач (1 мин)
next_tasks = projector.get_next_tasks(project_id, limit=5)

# Шаг 3.3: Приоритизация (1 мин)
prioritized = projector.prioritize_tasks(next_tasks, criteria=[
    "dependencies",
    "critical_path",
    "resource_availability"
])

🎯 СЛЕДУЮЩИЕ ЗАДАЧИ (Топ 5)

1. 🔴 КРИТИЧЕСКАЯ: Завершить Backend API auth module
   ├─ Assignee: Мария С.
   ├─ Deadline: 2025-12-15 (через 2 дня)
   ├─ Блокирует: Frontend login, Интеграцию с SSO
   └─ Оценка: 8 часов

2. 🔴 КРИТИЧЕСКАЯ: Нанять Frontend contractor
   ├─ Assignee: Наталья Р. (PM)
   ├─ Deadline: 2025-12-14 (срочно)
   ├─ Причина: Дмитрий болен, Frontend отстаёт
   └─ Оценка: 1 день

3. 🟡 ВАЖНАЯ: Разработать API для сделок
   ├─ Assignee: Алексей К.
   ├─ Deadline: 2025-12-20
   ├─ Зависит от: Task #1
   └─ Оценка: 16 часов

4. 🟡 ВАЖНАЯ: UI для управления контактами
   ├─ Assignee: Ольга В. + contractor
   ├─ Deadline: 2025-12-22
   ├─ Зависит от: Task #2
   └─ Оценка: 24 часа

5. 🟢 НОРМАЛЬНАЯ: Подготовка к интеграции с 1С
   ├─ Assignee: Сергей Б. (DevOps)
   ├─ Deadline: 2025-12-18
   ├─ Блокирует: Интеграционный этап
   └─ Оценка: 12 часов

═══════════════════════════════════════════════════

Начать с задачи #1? [да/нет]

# Шаг 4.1: Получение текущего этапа (30 сек)
current_stage = projector.get_current_stage(project_id)  # "execution"

# Шаг 4.2: Валидация критериев этапа (3 мин)
validation = projector.validate_stage_completion(project_id, current_stage)

# Для этапа ИСПОЛНЕНИЕ:
# - Deliverables готовы?
# - Quality metrics достигнуты?
# - Acceptance criteria выполнены?

# Шаг 4.3: Светофорная проверка (1 мин)
traffic_light = projector.calculate_stage_status(validation)

# Шаг 4.4: Рекомендации (1 мин)
if traffic_light == "GREEN":
    recommendation = "Этап можно завершить"
elif traffic_light == "YELLOW":
    recommendation = "Можно завершить с контролем"
elif traffic_light == "RED":
    recommendation = "БЛОКИРОВКА: устраните проблемы"
else:  # CRITICAL
    recommendation = "ЭСКАЛАЦИЯ: критические проблемы"

🔍 КОНТРОЛЬ ЭТАПА: ИСПОЛНЕНИЕ

КРИТЕРИИ ЗАВЕРШЕНИЯ:
├─ ✅ Deliverables определены (100%)
├─ 🔵 Deliverables готовы (40% из 100%)
│   ├─ Backend API: 70% ✅
│   ├─ Frontend UI: 30% ⚠️
│   └─ Интеграции: 0% ❌
│
├─ ✅ Quality metrics определены
├─ 🔵 Quality metrics достигнуты (95% из 98%)
│   ├─ Test coverage: 95% (target 98%)
│   ├─ Performance: ✅ (500ms < 1s target)
│   └─ Security scan: ✅ (0 critical issues)
│
├─ ❌ Acceptance criteria (не готовы для UAT)
└─ ❌ Stakeholder approval (не запрошено)

СВЕТОФОР: 🟡 ЖЁЛТЫЙ (прогресс есть, но не готов)

БЛОКИРОВКИ: Нет (прогресс в рамках плана)

РЕКОМЕНДАЦИЯ:
Продолжить работу над Frontend и Интеграциями.
Этап будет готов к завершению примерно через 6 недель.

Текущий срок: 2026-02-21
Прогноз: 2026-02-21 (в срок)

═══════════════════════════════════════════════════

Что делать?
1. Продолжить работу
2. Пересмотреть timeline
3. Изменить scope
4. Эскалировать проблему

# Шаг 5.1: Сбор данных (2 мин)
report_data = projector.collect_report_data(project_id)

# Шаг 5.2: Генерация отчёта (3 мин)
report = projector.generate_report({
    "project_id": project_id,
    "format": "markdown",  # или PDF, DOCX
    "sections": [
        "executive_summary",
        "progress_by_stages",
        "budget_status",
        "risks_and_issues",
        "next_steps"
    ]
})

# Шаг 5.3: Сохранение (1 мин)
report_path = f"projects/{project_id}/reports/report-{date.today()}.md"
projector.save_report(report, report_path)

📄 ОТЧЁТ СГЕНЕРИРОВАН

Файл: projects/PRJ-2025-001-TECH-B/reports/report-2025-12-13.md

СОДЕРЖАНИЕ:
1. Executive Summary
2. Progress by Stages
3. Budget Status
4. Risks and Issues
5. Next Steps

Отправить стейкхолдерам? [да/нет]

# Шаг 1.1: Определение ассистента (30 сек)
specialist = projector.get_specialist_for_project(project_id)

# Шаг 1.2: Подготовка контекста (1 мин)
context = {
    "project_id": project_id,
    "current_stage": current_stage,
    "data": collected_data,
    "previous_results": {
        "research": research_result if stage >= "analytics" else None,
        "analytics": analytics_result if stage >= "design" else None
    }
}

# Шаг 1.3: Формирование задачи (30 сек)
task = {
    "action": "conduct_research",  # или analytics, design, etc
    "context": context,
    "expected_output": {
        "hypotheses": 3,
        "competitors": 3,
        "alternatives": 3,
        "report": True
    }
}

# Шаг 2.1: Делегирование через Orchestrator (1 мин)
result = orchestrator.activate_agent(
    agent_name=specialist,  # "Technical Assistant"
    task_description=task["action"],
    context=task["context"]
)

# Шаг 2.2: Мониторинг выполнения (1-2 мин)
while not result.is_complete():
    status = orchestrator.check_agent_status(specialist)
    projector.log(f"Specialist status: {status}")
    time.sleep(5)

🤖 ДЕЛЕГИРОВАНИЕ: Technical Assistant

Задача: Провести исследование альтернатив
Контекст: PRJ-2025-001-TECH-B (CRM система)

⏳ Ассистент работает...
   [▓▓▓▓▓▓▓▓░░] 80%

✅ ЗАВЕРШЕНО (2 мин 15 сек)

# Шаг 3.1: Получение результата (30 сек)
specialist_result = orchestrator.get_agent_result(specialist)

# Шаг 3.2: Валидация (2 мин)
validation = projector.validate_specialist_result(
    specialist_result,
    expected_output=task["expected_output"]
)

# Шаг 3.3: Если валидация не прошла — повтор (опционально)
if not validation["valid"]:
    missing = validation["missing_fields"]
    specialist_result = orchestrator.activate_agent(
        specialist,
        f"Дополни результат: {missing}",
        context
    )

✅ РЕЗУЛЬТАТ ПОЛУЧЕН

Гипотезы: 5 ✓
Конкуренты: 4 ✓
Альтернативы: 3 ✓
Отчёт: Да ✓

ВАЛИДАЦИЯ: Пройдена

Интегрируем результат в проект...

# Шаг 1.1: Получение критериев для этапа (30 сек)
stage_criteria = projector.get_stage_criteria(current_stage, project_level)

# Для уровня B, этап СБОР ДАННЫХ:
# - 100% критичных данных
# - Нет противоречий
# - Constraints определены

# Шаг 1.2: Проверка каждого критерия (2 мин)
validation_results = {}
for criterion in stage_criteria:
    result = projector.validate_criterion(
        project_data,
        criterion
    )
    validation_results[criterion.id] = result

# Шаг 1.3: Расчёт процента выполнения (30 сек)
completion_rate = sum(validation_results.values()) / len(validation_results)

✅ ВАЛИДАЦИЯ ЭТАПА: СБОР ДАННЫХ

Критерии:
✅ Критичные данные собраны: 100%
✅ Противоречия отсутствуют: Да
✅ Constraints определены: Да
✅ Stakeholders идентифицированы: Да

ГОТОВНОСТЬ: 100%

# Шаг 2.1: Определение светофора (1 мин)
traffic_light = projector.calculate_traffic_light(completion_rate, blockers)

# Логика:
if completion_rate == 1.0 and len(blockers) == 0:
    traffic_light = "GREEN"   # Автопереход
elif completion_rate >= 0.9 and len(blockers) == 0:
    traffic_light = "YELLOW"  # Переход с контролем
elif completion_rate < 0.9:
    traffic_light = "RED"     # БЛОКИРОВКА
else:
    traffic_light = "CRITICAL"  # Эскалация

🚦 СВЕТОФОР: 🟢 ЗЕЛЁНЫЙ

Все критерии выполнены на 100%.
Блокировок нет.

РАЗРЕШЁН АВТОМАТИЧЕСКИЙ ПЕРЕХОД к следующему этапу.

# Шаг 3.1: Обновление статуса текущего этапа (30 сек)
projector.update_stage_status(
    project_id,
    current_stage,
    {
        "status": "completed",
        "completion_date": datetime.now(),
        "traffic_light": traffic_light
    }
)

# Шаг 3.2: Активация следующего этапа (30 сек)
next_stage = projector.get_next_stage(current_stage)
projector.activate_stage(project_id, next_stage)

# Шаг 3.3: Обновление PROJECT.md (30 сек)
projector.update_project_document(project_id, {
    "current_stage": next_stage,
    "stages": updated_stages
})

✅ ЭТАП ЗАВЕРШЁН: СБОР ДАННЫХ
   Статус: ✅ Завершён
   Дата: 2025-12-13
   Светофор: 🟢 ЗЕЛЁНЫЙ

🔵 СЛЕДУЮЩИЙ ЭТАП: ИССЛЕДОВАНИЯ
   Статус: 🔵 Активирован
   Начало: 2025-12-13

Начинаем исследования...

# Шаг 1.1: Извлечение ключевых слов (30 сек)
keywords = projector.extract_keywords(user_request)

# Шаг 1.2: Scoring по типам (1 мин)
type_scores = {}
for project_type in ["BIZ", "TECH", "MKT", "DSG", "DATA", "INFRA"]:
    score = projector.calculate_type_score(keywords, project_type)
    type_scores[project_type] = score

# Пример для "CRM система для управления клиентами":
# type_scores = {
#     "TECH": 0.85,  # ← максимальный
#     "BIZ": 0.60,
#     "MKT": 0.20,
#     ...
# }

# Шаг 1.3: Выбор типа (30 сек)
best_type = max(type_scores, key=type_scores.get)
confidence = type_scores[best_type]

🔍 АВТООПРЕДЕЛЕНИЕ ТИПА

Ключевые слова: CRM, система, клиенты, управление, сделки

Оценки:
├─ TECH: 0.85 ⭐ (система, CRM, управление)
├─ BIZ: 0.60 (клиенты, сделки)
├─ MKT: 0.20
├─ DSG: 0.10
├─ DATA: 0.15
└─ INFRA: 0.05

✅ ОПРЕДЕЛЁН ТИП: TECH (Техническая система)
   Уверенность: 85%

# Шаг 2.1: Извлечение индикаторов (1 мин)
indicators = {
    "duration": extract_duration(user_request),        # "6 месяцев"
    "team_size": extract_team_size(user_request),      # "10 человек"
    "budget": extract_budget(user_request),            # "$200K"
    "scope": analyze_scope(user_request)               # "средний"
}

# Шаг 2.2: Scoring по уровням (1 мин)
level_scores = {}
for level in ["A", "B", "C", "D"]:
    score = projector.calculate_level_score(indicators, level)
    level_scores[level] = score

# Пример:
# level_scores = {
#     "A": 0.20,
#     "B": 0.78,  # ← максимальный
#     "C": 0.55,
#     "D": 0.10
# }

# Шаг 2.3: Выбор уровня (30 сек)
best_level = max(level_scores, key=level_scores.get)
confidence = level_scores[best_level]

🔍 АВТООПРЕДЕЛЕНИЕ УРОВНЯ

Индикаторы:
├─ Срок: 6 месяцев → B (3-12 мес) ✓
├─ Команда: 10 человек → B (5-20 чел) ✓
├─ Бюджет: $200K → C (0.5-10 млн) ⚠️
└─ Масштаб: Средний → B ✓

Оценки:
├─ A: 0.20 (слишком масштабный)
├─ B: 0.78 ⭐ (большинство индикаторов)
├─ C: 0.55 (бюджет подходит)
└─ D: 0.10 (слишком долго)

✅ ОПРЕДЕЛЁН УРОВЕНЬ: B (Тактический)
   Уверенность: 78%

Подтвердить уровень B? [да/нет]

# Шаг 1.1: Валидация критериев (1 мин)
validation = projector.validate_stage_completion(project_id, current_stage)

# Шаг 1.2: Выявление блокеров (1 мин)
blockers = []
for criterion in validation["criteria"]:
    if not criterion["met"]:
        blocker = {
            "criterion": criterion["name"],
            "severity": criterion["severity"],  # CRITICAL, HIGH, MEDIUM
            "reason": criterion["failure_reason"]
        }
        blockers.append(blocker)

🚨 БЛОКИРОВКА ОБНАРУЖЕНА

Этап: АНАЛИТИКА
Светофор: 🔴 КРАСНЫЙ

БЛОКЕРЫ (2):
1. 🔴 КРИТИЧЕСКИЙ: Финансовая модель отсутствует
   Причина: ROI не рассчитан
   Влияние: Невозможно принять решение

2. 🟡 ВЫСОКИЙ: Риски не оценены
   Причина: Нет оценки вероятности и влияния
   Влияние: Нет понимания угроз проекту

# Шаг 2.1: Приоритизация блокеров (1 мин)
prioritized_blockers = sorted(blockers, key=lambda b: b["severity"], reverse=True)

# Шаг 2.2: Устранение каждого блокера (переменно)
for blocker in prioritized_blockers:
    if blocker["severity"] == "CRITICAL":
        # Немедленное действие
        projector.escalate_blocker(project_id, blocker)

        # Запрос действия у пользователя
        action = projector.request_blocker_resolution(blocker)

        # Выполнение
        if action == "delegate":
            result = projector.delegate_to_specialist(...)
        elif action == "manual":
            result = projector.wait_for_user_input(...)

🔧 УСТРАНЕНИЕ БЛОКИРОВКИ #1

Блокер: Финансовая модель отсутствует

Варианты:
1. Делегировать Business Assistant для расчёта ROI
2. Запросить данные у финансового отдела
3. Упростить модель (быстрая оценка)
4. Пропустить (НЕ РЕКОМЕНДУЕТСЯ)

Ваш выбор: [1/2/3/4]

✅ Делегируем Business Assistant...
⏳ Ассистент рассчитывает ROI...
✅ ГОТОВО (3 мин)

ROI для альтернатив:
- Альтернатива A: 180%
- Альтернатива B: 250%
- Альтернатива C: 220%

🟢 БЛОКИРОВКА УСТРАНЕНА

Осталось блокеров: 1
Переходим к устранению блокера #2...

# Эскалация
projector.escalate_to_orchestrator({
    "project_id": project_id,
    "stage": current_stage,
    "blocker": blocker,
    "attempts": 3,
    "reason": "Не удалось устранить блокировку"
})

# Orchestrator принимает решение:
# - Изменить scope проекта
# - Привлечь дополнительные ресурсы
# - Заморозить проект до устранения

⚫ КРИТИЧЕСКАЯ БЛОКИРОВКА

Блокер: Интеграция с 1С невозможна (API недоступен)
Попытки устранения: 3
Статус: НЕ УСТРАНЕНО

🚨 ЭСКАЛАЦИЯ к Orchestrator

Рекомендации:
1. Изменить scope: использовать CSV импорт вместо API
2. Заморозить проект до получения доступа к 1С API
3. Изменить альтернативу: отказаться от интеграции с 1С

Orchestrator принимает решение...

try:
    result = orchestrator.activate_agent(specialist, task, context)
except SpecialistError as e:
    # Логирование
    projector.log_error(f"Specialist {specialist} failed: {e}")

    # Retry (до 3 раз)
    for i in range(3):
        result = orchestrator.activate_agent(specialist, task, context)
        if result.success:
            break

    # Если всё ещё ошибка → эскалация
    if not result.success:
        projector.escalate_to_orchestrator({
            "error": "Specialist repeatedly failed",
            "specialist": specialist,
            "task": task
        })

validation = projector.validate_stage_completion(project_id, stage)
if not validation["valid"]:
    # Показать проблемы пользователю
    projector.show_validation_errors(validation["errors"])

    # Предложить исправления
    fixes = projector.suggest_fixes(validation["errors"])

    # Пользователь выбирает
    chosen_fix = projector.ask_user_to_choose(fixes)

    # Применяем исправление
    projector.apply_fix(chosen_fix)

try:
    project_md = projector.generate_project_md(data)
except GenerationError as e:
    # Fallback на шаблон
    project_md = projector.generate_from_template(data, "PROJECT_TEMPLATE.md")

    # Предупреждение пользователю
    projector.warn_user("Использован упрощённый шаблон документа")

# Шаг 1: Показать топ-3 типа
top_types = sorted(type_scores.items(), key=lambda x: x[1], reverse=True)[:3]

projector.show_user(f"""
⚠️ НЕОДНОЗНАЧНЫЙ ТИП ПРОЕКТА

Не удалось однозначно определить тип (confidence < 60%).

Возможные типы:
1. {top_types[0][0]}: {top_types[0][1]*100}%
2. {top_types[1][0]}: {top_types[1][1]*100}%
3. {top_types[2][0]}: {top_types[2][1]*100}%

Пожалуйста, выберите тип вручную или дайте больше деталей.
""")

# Шаг 2: Пользователь выбирает
user_choice = projector.ask_user("Выберите тип [1/2/3] или опишите подробнее:")

if user_choice in ["1", "2", "3"]:
    project_type = top_types[int(user_choice)-1][0]
else:
    # Повторное определение с новым описанием
    new_request = user_choice
    project_type = projector.detect_project_type(new_request)

# Шаг 1: Обнаружение конфликта
business_rec = business_assistant_result["recommendation"]  # "B (SaaS)"
technical_rec = technical_assistant_result["recommendation"]  # "C (Open Source)"

if business_rec != technical_rec:
    conflict = {
        "assistants": ["Business", "Technical"],
        "recommendations": [business_rec, technical_rec]
    }

    # Шаг 2: Анализ причин
    reasons = projector.analyze_conflict(conflict)
    # Пример: Business фокусируется на скорости, Technical — на контроле

    # Шаг 3: Показать пользователю
    projector.show_conflict({
        "conflict": conflict,
        "reasons": reasons,
        "recommendation": "Выбрать вручную на основе приоритетов"
    })

    # Шаг 4: Пользователь решает
    final_choice = projector.ask_user("""
    Конфликт рекомендаций:

    💼 Business Assistant: SaaS Битрикс24
       Причина: Быстрый запуск (2 недели), низкие риски

    💻 Technical Assistant: Open Source + кастомизация
       Причина: Полный контроль, гибкость, долгосрочная экономия

    Ваш выбор? [business/technical/другое]
    """)

# Шаг 1: Попытки устранения (3 раза)
for attempt in range(3):
    result = projector.try_resolve_blocker(blocker)
    if result.success:
        break

# Шаг 2: Если не удалось → эскалация
if not result.success:
    escalation = projector.escalate_blocker({
        "project_id": project_id,
        "blocker": blocker,
        "attempts": 3,
        "impact": "CRITICAL",
        "options": [
            "Change scope",
            "Add resources",
            "Freeze project",
            "Cancel project"
        ]
    })

    # Orchestrator или пользователь принимает решение
    decision = orchestrator.make_decision(escalation)

    if decision == "change_scope":
        # Пересмотр scope
        new_scope = projector.revise_scope(project_id, blocker)
    elif decision == "add_resources":
        # Привлечение ресурсов
        resources = projector.request_additional_resources(blocker)
    elif decision == "freeze":
        # Заморозка проекта
        projector.freeze_project(project_id, reason=blocker)
    elif decision == "cancel":
        # Отмена проекта
        projector.cancel_project(project_id, reason=blocker)