SUPER_AGENT — Универсальный алгоритм AI-агента

РЕКУРСИЯ ЗАДАЧ    — задача логически сложная → делим на подзадачи
                    дерево по смыслу, глубина не ограничена
                    параллельность где нет зависимостей

РЕКУРСИЯ БЛОКОВ   — задача слишком большая для контекста → делим на части
                    последовательные куски, каждый самодостаточен
                    НЕ смешивать с рекурсией задач

TEMPLATE_REGISTRY   — паттерны решений (JIT-компиляция задач)
AGENT_REGISTRY      — иерархия агентов с метриками здоровья
TOOL_REGISTRY       — инструменты: статус, интерфейс, покрытие тестами

SUPER_AGENT(task, context):

  [S1] CONTEXT_CHECK
       → оценить размер задачи
       → если > CONTEXT_LIMIT * 0.7: BLOCK_DECOMPOSE(task) → выполнять блоками

  [S2] MATCHER
       → поиск в TEMPLATE_REGISTRY по типу и структуре задачи
       → точное совпадение:   БЫСТРЫЙ ПУТЬ (инстанцировать шаблон)
       → частичное:           БЫСТРЫЙ ПУТЬ + дополнить
       → нет совпадения:      МЕДЛЕННЫЙ ПУТЬ

  [S3] ANALYZE  (только МЕДЛЕННЫЙ ПУТЬ)
       → тип задачи (code / docs / ops / data / design / test / meta)
       → размер: atomic или требует декомпозиции
       → зависимости от других задач
       → уровень риска: LOW / MEDIUM / HIGH / CRITICAL

  [S4] CLARIFY
       → режим A: вопросы к оператору (бизнес-решения, приоритеты)
       → режим B: агент-критик параллельно (техническая корректность)
       → режим C: cross-LLM валидация (только HIGH_RISK и CRITICAL)
       → повторять пока AMBIGUITY_SCORE = 0 и CONFLICT_SCORE = 0

  [S5] DECOMPOSE  (если не atomic)
       → разбить на подзадачи
       → определить зависимости между ними
       → оценить возможность параллельного выполнения

  [S6] RESOLVE
       → для каждой подзадачи найти агента:
           точное совпадение в AGENT_REGISTRY  → использовать
           частичное совпадение (≥70%)         → INHERIT + расширить
           нет совпадения                      → CREATE_AGENT (мета-задача рекурсивно)
       → для каждого агента найти инструменты:
           есть в TOOL_REGISTRY  → использовать
           нет                   → CREATE_TOOL (мета-задача рекурсивно) → добавить в реестр

  [S7] EXECUTE
       → PUSH_STACK(task, context)       — сохранить позицию
       → child_ctx = INHERIT(context, task)  — передать только нужное
       → запустить подзадачи:
           параллельно где нет зависимостей
           последовательно где есть
       → каждая подзадача: SUPER_AGENT(subtask, child_ctx)  — рекурсия
       → POP_STACK()                     — вернуться

  [S8] STEP_VERIFY  (после каждого EXECUTE)
       → anti-hallucination: запустить в sandbox, проверить реальный вывод
       → no-hardcode: статический анализ на магические значения
       → diff-spec: что в спеке не покрыто? что лишнее?
       → CONFIDENCE_SCORE = вычислить (см. блок 4)
       → действие по порогу (см. блок 4)

  [S9] INTEGRATE
       → собрать результаты подзадач
       → CHECKPOINT(task, result)
       → context = MERGE(context, result)
       → сохранить шаблон в TEMPLATE_REGISTRY если МЕДЛЕННЫЙ ПУТЬ
       → вернуть result

stack/
  000_root.yaml                    ← глобальный контекст проекта
  001_catalog/
    task.yaml                      ← задача + позиция + что осталось
    002_product_model/
      task.yaml
      003_validation/
        task.yaml                  ← ТЕКУЩИЙ УРОВЕНЬ

PUSH(task, ctx)  → mkdir NNN_name/ → записать task.yaml → войти
POP()            → прочитать родительский task.yaml → выйти наверх
RESUME()         → найти самую глубокую незавершённую папку → продолжить

id: "NNN_name"
depth: N
status: pending | in_progress | completed | blocked
task:
  type: code | docs | ops | data | design | test | meta
  description: "..."
  risk: low | medium | high | critical
context:
  inherited: [ключи из родительского контекста]
  local: {данные текущего уровня}
remaining_subtasks: [список незавершённых]
confidence_score: 0.0
divergence_log: []

Завершённая ветка → через 30 дней → переместить в stack/archive/YYYY-MM/
Активные → никогда не удалять автоматически

CONFIDENCE_SCORE = weighted_average(
  completeness    * 0.25,   ← всё из спеки покрыто?
  consistency     * 0.20,   ← нет внутренних противоречий?
  grounding       * 0.20,   ← каждый факт имеет источник?
  test_pass_rate  * 0.25,   ← % пройденных тестов
  n_version_match * 0.10    ← совпадение N независимых решений
)
→ результат: 0.0 — 1.0

≥ 0.85              PROCEED — продолжить нормально
0.60 – 0.84         PROCEED_UNCERTAIN — продолжить + запустить RESEARCHER фоном
0.40 – 0.59         PAUSE — исследовать глубже, параллельные ветки продолжают работу
< 0.40              STOP + ESCALATE к оператору
CONFLICT_SCORE > 0  ESCALATE немедленно (независимо от confidence)

N = 2  для HIGH_RISK
N = 3  для CRITICAL

Каждое решение: независимый агент, разный подход
Консенсус: совпадение ≥ ⌈N/2⌉ + 1 для принятия
Расхождение: место расхождения = зона риска → CLARIFY

Задача заблокирована (ESCALATE / PAUSE):
  → определить независимые ветки дерева задач
  → продолжить их выполнение параллельно
  → RESEARCHER запущен фоном → ищет ответ
  → разблокировка: оператор ответил ИЛИ RESEARCHER нашёл → MERGE → продолжить

Оператор принял решение противоречащее рекомендации агента:
  1. Принять решение оператора → выполнить немедленно
  2. Записать в DIVERGENCE_LOG:
       {task_type, task_id, ai_decision, ai_confidence,
        human_decision, human_reason, timestamp}
  3. Продолжить работу

IMPROVEMENT_TRIGGER если:
  DIVERGENCE_LOG[task_type].count >= THRESHOLD (по умолчанию: 3)
  ИЛИ
  BLOCK_HEALTH метрики: любые 2 в красной зоне одновременно

IMPROVE(block_type):
  1. Собрать все случаи расхождения для block_type
  2. Найти паттерн: где AI систематически ошибается?
  3. Сформулировать гипотезу улучшения шаблона
  4. Обновить TEMPLATE в TEMPLATE_REGISTRY (версионирование!)
  5. Регрессия: прогнать исторические задачи с новым шаблоном
  6. Сравнить метрики:
       улучшилось → принять → обновить реестр
       ухудшилось → откат шаблона → ESCALATE архитектору

BLOCK_HEALTH = {
  override_rate:     % задач где оператор переопределил AI
  rollback_rate:     % задач где пришлось откатиться
  verify_fail_rate:  % задач не прошедших VERIFY с первого раза
  confidence_avg:    средний CONFIDENCE_SCORE
  time_deviation:    отклонение реального времени от оценки
}

override_rate     > 30%  → AI не понимает предметную область
rollback_rate     > 20%  → шаблон ненадёжный
verify_fail_rate  > 25%  → критерии готовности неправильные
confidence_avg    < 0.60 → задачи типа слишком неопределённые
time_deviation    > 2.0x → декомпозиция неточная

BASE_AGENT
│  analyze(), clarify(), execute(), verify(), report()
│
├── ORCHESTRATOR_AGENT      декомпозиция + делегирование
│     decompose(), spawn(), integrate()
│
├── EXECUTOR_AGENT          атомарное выполнение
│     ├── CODE_AGENT
│     │     ├── PYTHON_AGENT   (+ python_tools)
│     │     ├── GO_AGENT       (+ go_tools)
│     │     └── JS_AGENT       (+ js_tools)
│     ├── DOCS_AGENT
│     ├── OPS_AGENT
│     └── DATA_AGENT
│
├── VERIFIER_AGENT          проверка + автоисправление
│     verify(), auto_fix(), escalate()
│     ├── TEST_AGENT          (unit, integration, e2e)
│     ├── CHAOS_AGENT         (personas, failure simulation)
│     └── SECURITY_AGENT      (xss, sqli, auth)
│
├── RESEARCHER_AGENT        поиск информации фоном
│     search(), synthesize(), score_source()
│
└── BUILDER_AGENT           создание недостающих инструментов
      analyze_gap(), build_tool(), register_tool()

Нужен агент для задачи X?
  → Найти ближайший в AGENT_REGISTRY по capabilities
  → Совпадение ≥ 70%: INHERIT(parent) + добавить только отличие
  → Совпадение < 70%: CREATE_AGENT с нуля
  → Не создавать дубли: проверить реестр ДО создания

[V0] Синтаксис/запуск    — работает? (sandbox execution)
[V1] Контракт            — соответствует спеке?
[V2] Граничные случаи    — пустой ввод, null, max, min?
[V3] Зависимости         — не сломал соседей?
[V4] Hardcode detector   — нет магических значений?
[V5] Diff-spec           — покрытие 100%? лишнего нет?

L1  UNIT          — каждая функция изолированно
L2  INTEGRATION   — блоки вместе, стыки
L3  E2E           — полные пользовательские сценарии
L4  PERSONAS      — expert, novice, hostile, distracted, impatient, mobile
L5  CHAOS         — infra, network, data, deps, concurrency, time
L6  LOAD          — под нагрузкой

Исправить всё найденное в PASS 3
→ повторить VERIFY_ALL
→ пока ISSUES = 0

TIER_FREE:                         (использовать в первую очередь)
  Google Gemini Flash    — бесплатный, быстрый, хорош для анализа
  Mistral (free tier)    — хорош для кода
  Groq (free tier)       — очень быстрый inference

TIER_PAID:                         (только для CRITICAL)
  Claude Opus            — архитектурные решения
  GPT-4                  — cross-validation

1. Отправить задачу + результат в N внешних LLM с промптом:
   "Найди противоречия, пробелы, ошибки, галлюцинации в этом решении"

2. Собрать ответы

3. Анализ:
   проблема найдена всеми    → CRITICAL, исправить обязательно
   проблема найдена частью   → WARN, рассмотреть
   уникальная у одного LLM   → на рассмотрение оператора

4. Экономия:
   бесплатные тарифы → использовать всегда для HIGH_RISK
   платные           → только CRITICAL или если бесплатные не справились

ACCOUNT_POOL: список аккаунтов по провайдерам
Политика ротации:
  → использовать аккаунт пока не исчерпан лимит
  → переключиться на следующий
  → вести статистику использования
  → уведомить оператора если все лимиты исчерпаны

Хранение: infra/SECRETS.md (credentials) + system/config/llm-pool.yaml (конфиг)

Первая встреча с типом задачи X:
  МЕДЛЕННЫЙ ПУТЬ: полный цикл S1-S9
  → в конце: сохранить ШАБЛОН_X в TEMPLATE_REGISTRY

Повторная встреча с похожей задачей:
  БЫСТРЫЙ ПУТЬ: MATCHER нашёл → инстанцировать → выполнить
  → пропустить ANALYZE + DECOMPOSE
  → только CLARIFY (параметры изменились?) + EXECUTE + VERIFY

template_id: "catalog_crud"
task_type: code
capabilities: [crud, rest_api, database]
decomposition:
  - {subtask: "model", agent: CODE_AGENT, tools: [db_tool]}
  - {subtask: "api", agent: CODE_AGENT, tools: [http_tool]}
  - {subtask: "tests", agent: TEST_AGENT, tools: [test_runner]}
parameters: [entity_name, fields, db_type]
health:
  usage_count: 0
  success_rate: 0.0
  avg_confidence: 0.0

PROFILER  → наблюдать: частота, скорость, откаты по каждому шаблону
OPTIMIZER → улучшать горячие пути (только после 10+ успешных использований)
PRUNER    → архивировать если usage_count = 0 за 90 дней
IMPROVER  → по IMPROVEMENT_TRIGGER обновлять шаблоны с версионированием

// Управление деревом задач
DECOMPOSE(task)           → subtasks[]
ATOMIC(task)              → bool
INTEGRATE(results[])      → result
BLOCK_DECOMPOSE(task)     → blocks[]   (по размеру контекста)

// Управление контекстом
INHERIT(ctx, subtask)     → child_ctx  (только нужное)
CACHE(ctx)                → summary    (сжатие для передачи)
MERGE(ctx, result)        → updated_ctx
PUSH_STACK(task, ctx)     → void
POP_STACK()               → (task, ctx)

// Качество
CLARIFY(task, ctx)        → validated_task
VERIFY(result, criteria)  → pass | issues[]
STEP_VERIFY(result)       → {v0..v5}
EXECUTE(task, ctx)        → result

// Реестры
MATCHER(task)             → template | null
RESOLVE_AGENT(task)       → agent
RESOLVE_TOOLS(task)       → tools[]

// Восстановление и обучение
ROLLBACK(task)            → void
CHECKPOINT(task, result)  → void
IMPROVE(block_type)       → updated_template