@gian-tiaga/eda 1.0.4 → 2.0.0

package/lib/install.js

@@ -4,6 +4,7 @@ import { randomUUID } from 'node:crypto';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { parse as parseYaml } from 'yaml';
 
 import { listAgents, listSkills } from './catalog.js';
 import { renderClaudeAgent } from './renderers/claude-agent.js';
@@ -36,6 +37,7 @@ const RETIRED_AGENTS = [
   'eda-commit-context'
 ];
 const MANIFEST_FILE = 'eda-manifest.json';
+const SETTINGS_VERSION = 3;
 const REVIEW_AGENT_DEFINITIONS = [
   {
     key: 'correctness',
@@ -69,6 +71,14 @@ const REVIEW_AGENT_DEFINITIONS = [
     claude: 'haiku',
     codex: 'gpt-5.6-luna'
   },
+  {
+    key: 'business',
+    description: 'Проверяет изменённое поведение по применимым карточкам из docs/business/.',
+    auto: 'В auto запускается только когда изменения затрагивают поведение с применимой business-карточкой.',
+    mode: 'auto',
+    claude: 'sonnet',
+    codex: 'gpt-5.6-terra'
+  },
   {
     key: 'plan_alignment',
     description: 'Проверяет, что реализация соответствует указанному или однозначно найденному плану.',
@@ -160,11 +170,126 @@ const DEFAULT_REVIEW_AGENTS = Object.fromEntries(REVIEW_AGENT_DEFINITIONS.map(ag
     }
   }
 ]));
+const PLAN_REVIEW_AGENT_DEFINITIONS = [
+  {
+    key: 'requirements',
+    description: 'Проверяет соответствие плана задаче, scope, критериям готовности и применимым business-требованиям.',
+    auto: 'Эта базовая проверка по умолчанию запускается всегда.',
+    mode: 'always',
+    claude: 'sonnet',
+    codex: 'gpt-5.6-terra'
+  },
+  {
+    key: 'rules',
+    description: 'Проверяет соблюдение AGENTS.md, CLAUDE.md и docs/rules.md.',
+    auto: 'Эта базовая проверка по умолчанию запускается всегда.',
+    mode: 'always',
+    claude: 'haiku',
+    codex: 'gpt-5.6-luna'
+  },
+  {
+    key: 'architecture',
+    description: 'Проверяет архитектурные границы, зависимости и соответствие docs/arch.md.',
+    auto: 'Эта базовая проверка по умолчанию запускается всегда.',
+    mode: 'always',
+    claude: 'opus',
+    codex: 'gpt-5.6-sol'
+  },
+  {
+    key: 'feasibility',
+    description: 'Проверяет реализуемость плана относительно фактического кода и отсутствие скрытого исследования.',
+    auto: 'Эта базовая проверка по умолчанию запускается всегда.',
+    mode: 'always',
+    claude: 'opus',
+    codex: 'gpt-5.6-sol'
+  },
+  {
+    key: 'execution',
+    description: 'Проверяет связность фаз, ID задач, зависимости и размер работы для одного исполнителя.',
+    auto: 'Эта базовая проверка по умолчанию запускается всегда.',
+    mode: 'always',
+    claude: 'sonnet',
+    codex: 'gpt-5.6-terra'
+  },
+  {
+    key: 'verification',
+    description: 'Проверяет тесты, команды проверок, ошибки, логирование, документацию и эксплуатационную готовность.',
+    auto: 'Эта базовая проверка по умолчанию запускается всегда.',
+    mode: 'always',
+    claude: 'sonnet',
+    codex: 'gpt-5.6-terra'
+  },
+  {
+    key: 'api',
+    description: 'Проверяет API, DTO, события, очереди, внешние интеграции и совместимость контрактов.',
+    auto: 'В auto запускается при изменении API, событий, очередей или внешних интеграций.',
+    mode: 'auto',
+    claude: 'sonnet',
+    codex: 'gpt-5.6-terra'
+  },
+  {
+    key: 'database',
+    description: 'Проверяет схему данных, миграции, backfill, индексы, транзакции и rollback.',
+    auto: 'В auto запускается при изменении хранения, моделей, SQL, схем или миграций.',
+    mode: 'auto',
+    claude: 'opus',
+    codex: 'gpt-5.6-sol'
+  },
+  {
+    key: 'security',
+    description: 'Проверяет auth, permissions, внешний ввод, секреты, персональные данные и опасные операции.',
+    auto: 'В auto запускается для auth, permissions, внешнего ввода, секретов и чувствительных данных.',
+    mode: 'auto',
+    claude: 'opus',
+    codex: 'gpt-5.6-sol'
+  },
+  {
+    key: 'frontend',
+    description: 'Проверяет пользовательский сценарий, состояния UI, ошибки, accessibility и адаптивность.',
+    auto: 'В auto запускается для компонентов, стилей, клиентских маршрутов и состояния UI.',
+    mode: 'auto',
+    claude: 'sonnet',
+    codex: 'gpt-5.6-terra'
+  },
+  {
+    key: 'performance',
+    description: 'Проверяет нагрузку, запросы, конкурентность, кеши и горячие пути.',
+    auto: 'В auto запускается для запросов, пакетной обработки, кешей, конкурентности и горячих путей.',
+    mode: 'auto',
+    claude: 'opus',
+    codex: 'gpt-5.6-sol'
+  },
+  {
+    key: 'previous',
+    description: 'Проверяет закрытие findings предыдущей связанной итерации plan-review.',
+    auto: 'В auto запускается только при наличии связанной цепочки review/fix для текущего SHA-256 плана.',
+    mode: 'auto',
+    claude: 'haiku',
+    codex: 'gpt-5.6-luna'
+  }
+];
+const DEFAULT_PLAN_REVIEW_AGENTS = Object.fromEntries(PLAN_REVIEW_AGENT_DEFINITIONS.map(agent => [
+  agent.key,
+  {
+    mode: agent.mode,
+    model: {
+      claude: agent.claude,
+      codex: agent.codex
+    }
+  }
+]));
 const ORHESTRA_STEP_DEFINITIONS = [
   {
     id: 'plan',
     skill: 'eda-plan',
-    name: 'Планирование через eda-plan',
+    name: 'Планирование без проверок через eda-plan',
+    enabled: true,
+    args: 'без проверок'
+  },
+  {
+    id: 'plan-polish',
+    skill: 'eda-plan-polish',
+    name: 'Полировка плана через eda-plan-polish',
     enabled: true,
     args: ''
   },
@@ -191,7 +316,7 @@ const ORHESTRA_STEP_DEFINITIONS = [
     onFailure: {
       skill: 'eda-fix',
       args: '',
-      then: ['polish', 'manual-test'],
+      then: ['manual-test'],
       maxCycles: 5
     }
   }
@@ -211,13 +336,18 @@ const DEFAULT_SETTINGS = {
   },
   plan: {
     strict: false,
+    review: true,
     size: 'normal',
     decisionMode: 'recommend_and_ask',
     testStrategy: 'ask_each_time',
     loggingStrategy: 'ask_each_time'
   },
+  planReview: {
+    threshold: 95,
+    agents: DEFAULT_PLAN_REVIEW_AGENTS
+  },
   planPolish: {
-    strict: false
+    limit: 3
   },
   review: {
     agents: DEFAULT_REVIEW_AGENTS
@@ -229,28 +359,49 @@ const DEFAULT_SETTINGS = {
     includePlans: false
   }
 };
+const SETTINGS_SECTION_NAMES = [
+  'orhestra',
+  'aim',
+  'explore',
+  'plan',
+  'plan-review',
+  'plan-polish',
+  'review',
+  'send-review',
+  'discover-automations'
+];
 const SETTINGS_CHOICES = [
   {
+    section: 'explore',
+    key: 'explore.strict',
     value: 'exploreStrict',
     name: 'Strict по умолчанию для eda-explore',
     checked: DEFAULT_SETTINGS.explore.strict
   },
   {
+    section: 'plan',
+    key: 'plan.strict',
     value: 'planStrict',
     name: 'Strict по умолчанию для eda-plan',
     checked: DEFAULT_SETTINGS.plan.strict
   },
   {
-    value: 'planPolishStrict',
-    name: 'Strict по умолчанию для eda-plan-polish',
-    checked: DEFAULT_SETTINGS.planPolish.strict
+    section: 'plan',
+    key: 'plan.review',
+    value: 'planReview',
+    name: 'Запускать eda-plan-review внутри eda-plan',
+    checked: DEFAULT_SETTINGS.plan.review
   },
   {
+    section: 'send-review',
+    key: 'sendReview.closePreviousReviews',
     value: 'sendReviewClosePreviousReviews',
     name: 'Закрывать предыдущие ревью eda-send-review',
     checked: DEFAULT_SETTINGS.sendReview.closePreviousReviews
   },
   {
+    section: 'discover-automations',
+    key: 'discoverAutomations.includePlans',
     value: 'discoverAutomationsIncludePlans',
     name: 'Анализировать планы в eda-discover-automations по умолчанию',
     checked: DEFAULT_SETTINGS.discoverAutomations.includePlans
@@ -280,6 +431,14 @@ const ORHESTRA_POLISH_LIMIT_CHOICES = [1, 2, 3, 5, 10].map(value => ({
   value,
   name: `${value} ${value === 1 ? 'итерация' : value < 5 ? 'итерации' : 'итераций'}`
 }));
+const PLAN_REVIEW_THRESHOLD_CHOICES = [90, 95, 100].map(value => ({
+  value,
+  name: `${value}/100`
+}));
+const PLAN_POLISH_LIMIT_CHOICES = [1, 2, 3, 5, 10].map(value => ({
+  value,
+  name: `${value} ${value === 1 ? 'итерация' : value < 5 ? 'итерации' : 'итераций'}`
+}));
 const PLAN_SIZE_CHOICES = [
   {
     value: 'normal',
@@ -355,6 +514,16 @@ const CODEX_REVIEW_MODEL_CHOICES = [
   { value: 'gpt-5.6-terra', name: 'gpt-5.6-terra — сильная проверка кода' },
   { value: 'gpt-5.6-sol', name: 'gpt-5.6-sol — максимальная глубина' }
 ];
+const UPDATE_ALL_SETTINGS_MODE_CHOICES = [
+  {
+    value: 'configure',
+    name: 'Настроить один общий профиль и записать его во все проекты'
+  },
+  {
+    value: 'skip',
+    name: 'Skip — сохранить полный v3, остальные конфиги перенести с defaults'
+  }
+];
 
 export async function init({ cwd, input = process.stdin, output = process.stdout }) {
   const targets = await askTargets({ input, output });
@@ -381,7 +550,8 @@ export async function updateAll({
   root = process.cwd(),
   input = process.stdin,
   output = process.stdout,
-  maxDepth = UPDATE_ALL_MAX_DEPTH
+  maxDepth = UPDATE_ALL_MAX_DEPTH,
+  settingsMode
 } = {}) {
   if (!Number.isInteger(maxDepth) || maxDepth < 0) {
     throw new Error('Глубина поиска должна быть неотрицательным целым числом.');
@@ -409,9 +579,20 @@ export async function updateAll({
   }
 
   output.write(`Найдено ${formatProjectCount(projects.length)}: ${projects.map(project => formatProjectPath(rootDir, project)).join(', ')}\n`);
-  output.write('Настройки будут запрошены один раз и записаны одинаково во все найденные проекты.\n');
-  const sharedSettings = await askSettings({ input, output });
-  const sharedSettingsContent = formatSettings(sharedSettings);
+  const resolvedSettingsMode = settingsMode ?? await askUpdateAllSettingsMode({ input, output });
+  if (!['configure', 'skip'].includes(resolvedSettingsMode)) {
+    throw new Error(`Неизвестный режим настроек update-all: ${resolvedSettingsMode}.`);
+  }
+
+  let sharedSettingsContent;
+  if (resolvedSettingsMode === 'configure') {
+    output.write('Настройки будут запрошены один раз и записаны одинаково во все найденные проекты.\n');
+    const sharedSettings = await askSettings({ input, output });
+    sharedSettingsContent = formatSettings(sharedSettings);
+  } else {
+    output.write(`Режим skip: полный version: ${SETTINGS_VERSION} сохраняется, старые конфиги переносятся, отсутствующие создаются с defaults.\n`);
+    sharedSettingsContent = formatSettings(structuredClone(DEFAULT_SETTINGS));
+  }
 
   const updatedProjects = [];
   const skippedProjects = [];
@@ -430,8 +611,22 @@ export async function updateAll({
       }
 
       output.write(`Найдены установленные среды: ${targets.join(', ')}\n`);
-      await writeSettingsContent(projectDir, sharedSettingsContent);
-      output.write(`Записан общий файл настроек: ${SETTINGS_RELATIVE_PATH}\n`);
+      const projectSettingsPath = path.join(projectDir, SETTINGS_RELATIVE_PATH);
+      if (resolvedSettingsMode === 'skip' && await fileExists(projectSettingsPath)) {
+        const existingContent = await fs.readFile(projectSettingsPath, 'utf8');
+        const migrated = migrateSettingsContent(existingContent);
+        if (migrated.version === SETTINGS_VERSION && migrated.missingKeys.size === 0) {
+          output.write(`Полный файл настроек сохранён: ${SETTINGS_RELATIVE_PATH}\n`);
+        } else {
+          await writeSettingsContent(projectDir, formatSettings(migrated.settings));
+          output.write(`Старый или неполный файл настроек перенесён на version: ${SETTINGS_VERSION}: ${SETTINGS_RELATIVE_PATH}\n`);
+        }
+      } else {
+        await writeSettingsContent(projectDir, sharedSettingsContent);
+        output.write(resolvedSettingsMode === 'skip'
+          ? `Создан файл настроек с defaults: ${SETTINGS_RELATIVE_PATH}\n`
+          : `Записан общий файл настроек: ${SETTINGS_RELATIVE_PATH}\n`);
+      }
       const result = await syncPackage(projectDir, targets, output, {
         action: 'update',
         writeDone: false
@@ -459,6 +654,7 @@ export async function updateAll({
   return {
     root: rootDir,
     maxDepth,
+    settingsMode: resolvedSettingsMode,
     projects,
     updatedProjects,
     skippedProjects,
@@ -486,189 +682,211 @@ export async function askTargets({ input = process.stdin, output = process.stdou
   });
 }
 
-export async function askSettings({ input = process.stdin, output = process.stdout } = {}) {
+export async function askUpdateAllSettingsMode({
+  input = process.stdin,
+  output = process.stdout,
+  selectPrompt = select
+} = {}) {
   if (!input.isTTY || !output.isTTY) {
-    output.write(`Нет интерактивного терминала — использую настройки ${SETTINGS_RELATIVE_PATH} по умолчанию.\n`);
-    return structuredClone(DEFAULT_SETTINGS);
+    output.write(`Нет интерактивного терминала — использую режим skip: сохраняю полный v3, старые конфиги переношу с defaults.\n`);
+    return 'skip';
   }
 
-  const selected = await checkbox({
-    message: 'Какие настройки включить?',
-    instructions: 'Стрелки — выбрать, Space — отметить, Enter — продолжить',
-    choices: SETTINGS_CHOICES
+  return selectPrompt({
+    message: `Как обновить ${SETTINGS_RELATIVE_PATH} в найденных проектах?`,
+    choices: UPDATE_ALL_SETTINGS_MODE_CHOICES,
+    default: 'configure'
   }, {
     input,
     output
   });
+}
 
-  const orhestraMode = await select({
-    message: 'Как eda-orhestra должен вести полный цикл по умолчанию?',
-    choices: ORHESTRA_MODE_CHOICES,
-    default: DEFAULT_SETTINGS.orhestra.mode
-  }, {
-    input,
-    output
-  });
+export async function askSettings({
+  input = process.stdin,
+  output = process.stdout,
+  sections = SETTINGS_SECTION_NAMES,
+  checkboxPrompt = checkbox,
+  selectPrompt = select,
+  seedSettings = DEFAULT_SETTINGS,
+  missingKeys = null
+} = {}) {
+  const settings = structuredClone(seedSettings);
+  if (!input.isTTY || !output.isTTY) {
+    output.write(`Нет интерактивного терминала — использую перенесённые значения и defaults ${SETTINGS_RELATIVE_PATH}.\n`);
+    return settings;
+  }
 
-  const enabledOrhestraSteps = await checkbox({
-    message: 'Какие этапы eda-orhestra включить по умолчанию?',
-    instructions: 'Порядок можно изменить вручную в docs/settings.yaml',
-    choices: ORHESTRA_STEP_DEFINITIONS.map(step => ({
-      name: step.name,
-      value: step.skill,
-      checked: step.enabled
-    }))
-  }, {
-    input,
-    output
-  });
+  const requestedSections = new Set(sections);
+  const shouldAsk = key => missingKeys === null || missingKeys.has(key);
+  const booleanChoices = SETTINGS_CHOICES.filter(choice => (
+    requestedSections.has(choice.section) && shouldAsk(choice.key)
+  ));
+  const selected = booleanChoices.length > 0
+    ? await checkboxPrompt({
+        message: 'Какие настройки включить?',
+        instructions: 'Стрелки — выбрать, Space — отметить, Enter — продолжить',
+        choices: booleanChoices.map(({ section, key, ...choice }) => choice)
+      }, { input, output })
+    : [];
+
+  if (requestedSections.has('explore') && shouldAsk('explore.strict')) {
+    settings.explore.strict = selected.includes('exploreStrict');
+  }
+  if (requestedSections.has('plan') && shouldAsk('plan.strict')) {
+    settings.plan.strict = selected.includes('planStrict');
+  }
+  if (requestedSections.has('plan') && shouldAsk('plan.review')) {
+    settings.plan.review = selected.includes('planReview');
+  }
+  if (requestedSections.has('send-review') && shouldAsk('sendReview.closePreviousReviews')) {
+    settings.sendReview.closePreviousReviews = selected.includes('sendReviewClosePreviousReviews');
+  }
+  if (requestedSections.has('discover-automations') && shouldAsk('discoverAutomations.includePlans')) {
+    settings.discoverAutomations.includePlans = selected.includes('discoverAutomationsIncludePlans');
+  }
+
+  if (requestedSections.has('orhestra') && shouldAsk('orhestra.mode')) {
+    settings.orhestra.mode = await selectPrompt({
+      message: 'Как eda-orhestra должен вести полный цикл по умолчанию?',
+      choices: ORHESTRA_MODE_CHOICES,
+      default: settings.orhestra.mode
+    }, { input, output });
+  }
 
-  const polishLimit = enabledOrhestraSteps.includes('eda-polish')
-    ? await select({
+  if (requestedSections.has('orhestra') && shouldAsk('orhestra.steps')) {
+    const enabledSteps = await checkboxPrompt({
+      message: 'Какие этапы eda-orhestra включить по умолчанию?',
+      instructions: 'Порядок можно изменить вручную в docs/settings.yaml',
+      choices: ORHESTRA_STEP_DEFINITIONS.map(step => ({
+        name: step.name,
+        value: step.skill,
+        checked: settings.orhestra.steps.find(item => item.skill === step.skill)?.enabled !== false
+      }))
+    }, { input, output });
+    const codePolishLimit = enabledSteps.includes('eda-polish')
+      ? await selectPrompt({
         message: 'Сколько итераций разрешить eda-polish внутри eda-orhestra?',
         choices: ORHESTRA_POLISH_LIMIT_CHOICES,
         default: 5
-      }, {
-        input,
-        output
-      })
-    : 5;
-
-  const orhestraSteps = DEFAULT_ORHESTRA_STEPS.map(step => ({
-    ...step,
-    enabled: enabledOrhestraSteps.includes(step.skill),
-    ...(step.skill === 'eda-polish' ? { args: `limit ${polishLimit}` } : {})
-  }));
-
-  const aimMode = await select({
-    message: 'Как eda-aim должен отвечать на рабочие вопросы по умолчанию?',
-    choices: AIM_MODE_CHOICES,
-    default: DEFAULT_SETTINGS.aim.mode
-  }, {
-    input,
-    output
-  });
-
-  const exploreDecisionMode = await select({
-    message: 'Как принимать важные решения в eda-explore?',
-    choices: DECISION_MODE_CHOICES,
-    default: DEFAULT_SETTINGS.explore.decisionMode
-  }, {
-    input,
-    output
-  });
-
-  const planSize = await select({
-    message: 'Какой размер плана eda-plan использовать по умолчанию?',
-    choices: PLAN_SIZE_CHOICES,
-    default: DEFAULT_SETTINGS.plan.size
-  }, {
-    input,
-    output
-  });
+      }, { input, output })
+      : 5;
+    settings.orhestra.steps = DEFAULT_ORHESTRA_STEPS.map(step => ({
+      ...step,
+      enabled: enabledSteps.includes(step.skill),
+      ...(step.skill === 'eda-polish' ? { args: `limit ${codePolishLimit}` } : {})
+    }));
+  }
 
-  const planDecisionMode = await select({
-    message: 'Как принимать важные решения в eda-plan?',
-    choices: DECISION_MODE_CHOICES,
-    default: DEFAULT_SETTINGS.plan.decisionMode
-  }, {
-    input,
-    output
-  });
+  const scalarPrompts = [
+    ['aim', 'aim.mode', settings.aim, 'mode', 'Как eda-aim должен отвечать на рабочие вопросы по умолчанию?', AIM_MODE_CHOICES],
+    ['explore', 'explore.decisionMode', settings.explore, 'decisionMode', 'Как принимать важные решения в eda-explore?', DECISION_MODE_CHOICES],
+    ['plan', 'plan.size', settings.plan, 'size', 'Какой размер плана eda-plan использовать по умолчанию?', PLAN_SIZE_CHOICES],
+    ['plan', 'plan.decisionMode', settings.plan, 'decisionMode', 'Как принимать важные решения в eda-plan?', DECISION_MODE_CHOICES],
+    ['plan', 'plan.testStrategy', settings.plan, 'testStrategy', 'Какую стратегию тестов eda-plan использовать по умолчанию?', TEST_STRATEGY_CHOICES],
+    ['plan', 'plan.loggingStrategy', settings.plan, 'loggingStrategy', 'Какую стратегию логирования eda-plan использовать по умолчанию?', LOGGING_STRATEGY_CHOICES],
+    ['plan-review', 'planReview.threshold', settings.planReview, 'threshold', 'Какой порог готовности использовать в eda-plan-review?', PLAN_REVIEW_THRESHOLD_CHOICES],
+    ['plan-polish', 'planPolish.limit', settings.planPolish, 'limit', 'Сколько review-итераций разрешить eda-plan-polish?', PLAN_POLISH_LIMIT_CHOICES]
+  ];
+  for (const [section, key, target, property, message, choices] of scalarPrompts) {
+    if (!requestedSections.has(section) || !shouldAsk(key)) continue;
+    target[property] = await selectPrompt({ message, choices, default: target[property] }, { input, output });
+  }
 
-  const testStrategy = await select({
-    message: 'Какую стратегию тестов eda-plan использовать по умолчанию?',
-    choices: TEST_STRATEGY_CHOICES,
-    default: DEFAULT_SETTINGS.plan.testStrategy
-  }, {
-    input,
-    output
-  });
+  if (requestedSections.has('plan-review')) {
+    settings.planReview.agents = await askPlanReviewAgentSettings({
+      input,
+      output,
+      selectPrompt,
+      seedAgents: settings.planReview.agents,
+      missingKeys
+    });
+  }
+  if (requestedSections.has('review')) {
+    settings.review.agents = await askReviewAgentSettings({
+      input,
+      output,
+      selectPrompt,
+      seedAgents: settings.review.agents,
+      missingKeys
+    });
+  }
+  return settings;
+}
 
-  const loggingStrategy = await select({
-    message: 'Какую стратегию логирования eda-plan использовать по умолчанию?',
-    choices: LOGGING_STRATEGY_CHOICES,
-    default: DEFAULT_SETTINGS.plan.loggingStrategy
-  }, {
+export async function askReviewAgentSettings({
+  input = process.stdin,
+  output = process.stdout,
+  selectPrompt = select,
+  seedAgents = DEFAULT_REVIEW_AGENTS,
+  missingKeys = null
+} = {}) {
+  return askAgentSettings({
     input,
-    output
+    output,
+    selectPrompt,
+    definitions: REVIEW_AGENT_DEFINITIONS,
+    seedAgents,
+    missingKeys,
+    keyPrefix: 'review.agents',
+    label: 'review'
   });
-
-  const reviewAgents = await askReviewAgentSettings({ input, output });
-
-  return {
-    orhestra: {
-      mode: orhestraMode,
-      steps: orhestraSteps
-    },
-    aim: {
-      mode: aimMode
-    },
-    explore: {
-      strict: selected.includes('exploreStrict'),
-      decisionMode: exploreDecisionMode
-    },
-    plan: {
-      strict: selected.includes('planStrict'),
-      size: planSize,
-      decisionMode: planDecisionMode,
-      testStrategy,
-      loggingStrategy
-    },
-    planPolish: {
-      strict: selected.includes('planPolishStrict')
-    },
-    review: {
-      agents: reviewAgents
-    },
-    sendReview: {
-      closePreviousReviews: selected.includes('sendReviewClosePreviousReviews')
-    },
-    discoverAutomations: {
-      includePlans: selected.includes('discoverAutomationsIncludePlans')
-    }
-  };
 }
 
-export async function askReviewAgentSettings({
+export async function askPlanReviewAgentSettings({
   input = process.stdin,
   output = process.stdout,
-  selectPrompt = select
+  selectPrompt = select,
+  seedAgents = DEFAULT_PLAN_REVIEW_AGENTS,
+  missingKeys = null
 } = {}) {
-  const reviewAgents = {};
-  for (const agent of REVIEW_AGENT_DEFINITIONS) {
-    const mode = await selectPrompt({
-      message: `Когда запускать review-проверку ${agent.key}?`,
-      choices: REVIEW_MODE_CHOICES,
-      default: agent.mode
-    }, {
-      input,
-      output
-    });
+  return askAgentSettings({
+    input,
+    output,
+    selectPrompt,
+    definitions: PLAN_REVIEW_AGENT_DEFINITIONS,
+    seedAgents,
+    missingKeys,
+    keyPrefix: 'planReview.agents',
+    label: 'plan-review'
+  });
+}
 
-    let claude = agent.claude;
-    let codex = agent.codex;
-    if (mode !== 'off') {
+async function askAgentSettings({ input, output, selectPrompt, definitions, seedAgents, missingKeys, keyPrefix, label }) {
+  const configuredAgents = structuredClone(seedAgents);
+  const shouldAsk = key => missingKeys === null || missingKeys.has(key);
+  for (const agent of definitions) {
+    const modeKey = `${keyPrefix}.${agent.key}.mode`;
+    const claudeKey = `${keyPrefix}.${agent.key}.model.claude`;
+    const codexKey = `${keyPrefix}.${agent.key}.model.codex`;
+    let mode = configuredAgents[agent.key].mode;
+    if (shouldAsk(modeKey)) {
+      mode = await selectPrompt({
+        message: `Когда запускать ${label}-проверку ${agent.key}?`,
+        choices: REVIEW_MODE_CHOICES,
+        default: mode
+      }, { input, output });
+    }
+
+    let claude = configuredAgents[agent.key].model.claude;
+    let codex = configuredAgents[agent.key].model.codex;
+    if (mode !== 'off' && shouldAsk(claudeKey)) {
       claude = await selectPrompt({
         message: `Какой моделью Claude проверять ${agent.key}?`,
         choices: CLAUDE_REVIEW_MODEL_CHOICES,
-        default: agent.claude
-      }, {
-        input,
-        output
-      });
+        default: claude
+      }, { input, output });
+    }
+    if (mode !== 'off' && shouldAsk(codexKey)) {
       codex = await selectPrompt({
         message: `Какой моделью Codex проверять ${agent.key}?`,
         choices: CODEX_REVIEW_MODEL_CHOICES,
-        default: agent.codex
-      }, {
-        input,
-        output
-      });
+        default: codex
+      }, { input, output });
     }
-    reviewAgents[agent.key] = { mode, model: { claude, codex } };
+    configuredAgents[agent.key] = { mode, model: { claude, codex } };
   }
-  return reviewAgents;
+  return configuredAgents;
 }
 
 async function detectTargets(cwd) {
@@ -793,19 +1011,58 @@ async function findInstalledProjects(rootDir, maxDepth) {
 }
 
 async function ensureSettings(cwd, { input = process.stdin, output = process.stdout } = {}) {
-  const existing = await migrateSettingsIfNeeded(cwd, { output });
-  if (existing.exists) return;
+  const settingsPath = path.join(cwd, SETTINGS_RELATIVE_PATH);
+  const existingContent = await readFileIfExists(settingsPath);
+  if (existingContent === null) {
+    const settings = await askSettings({ input, output });
+    await writeSettingsContent(cwd, formatSettings(settings));
+    output.write(`Создан файл настроек: ${SETTINGS_RELATIVE_PATH}\n`);
+    return;
+  }
 
-  const settings = await askSettings({ input, output });
+  const migrated = migrateSettingsContent(existingContent);
+  if (migrated.version === SETTINGS_VERSION && migrated.missingKeys.size === 0) {
+    output.write(`Настройки уже есть: ${SETTINGS_RELATIVE_PATH}\n`);
+    return;
+  }
+
+  output.write(`Переношу ${SETTINGS_RELATIVE_PATH} на version: ${SETTINGS_VERSION}; спрашиваются только отсутствующие значения.\n`);
+  const settings = await askSettings({
+    input,
+    output,
+    seedSettings: migrated.settings,
+    missingKeys: migrated.missingKeys
+  });
   await writeSettingsContent(cwd, formatSettings(settings));
-  output.write(`Создан файл настроек: ${SETTINGS_RELATIVE_PATH}\n`);
+  output.write(`Переписан файл настроек: ${SETTINGS_RELATIVE_PATH} → version: ${SETTINGS_VERSION}.\n`);
 }
 
 async function configureSettings(cwd, { input = process.stdin, output = process.stdout } = {}) {
-  output.write(`Настраиваю ${SETTINGS_RELATIVE_PATH} заново.\n`);
-  const settings = await askSettings({ input, output });
+  const settingsPath = path.join(cwd, SETTINGS_RELATIVE_PATH);
+  const existingContent = await readFileIfExists(settingsPath);
+  if (existingContent === null) {
+    output.write(`Настраиваю ${SETTINGS_RELATIVE_PATH} заново.\n`);
+    const settings = await askSettings({ input, output });
+    await writeSettingsContent(cwd, formatSettings(settings));
+    output.write(`Записан файл настроек: ${SETTINGS_RELATIVE_PATH}\n`);
+    return;
+  }
+
+  const migrated = migrateSettingsContent(existingContent);
+  if (migrated.version === SETTINGS_VERSION && migrated.missingKeys.size === 0) {
+    output.write(`Настройки ${SETTINGS_RELATIVE_PATH} версии ${SETTINGS_VERSION} полные — вопросы не требуются.\n`);
+    return;
+  }
+
+  output.write(`Переношу ${SETTINGS_RELATIVE_PATH} на version: ${SETTINGS_VERSION}; спрашиваются только отсутствующие значения.\n`);
+  const settings = await askSettings({
+    input,
+    output,
+    seedSettings: migrated.settings,
+    missingKeys: migrated.missingKeys
+  });
   await writeSettingsContent(cwd, formatSettings(settings));
-  output.write(`Записан файл настроек: ${SETTINGS_RELATIVE_PATH}\n`);
+  output.write(`Переписан файл настроек: ${SETTINGS_RELATIVE_PATH} → version: ${SETTINGS_VERSION}.\n`);
 }
 
 async function writeSettingsContent(cwd, content) {
@@ -818,144 +1075,173 @@ async function writeSettingsContent(cwd, content) {
   await fs.writeFile(settingsPath, content);
 }
 
-async function migrateSettingsIfNeeded(cwd, {
-  output = process.stdout,
-  reportExisting = true
-} = {}) {
-  const settingsPath = path.join(cwd, SETTINGS_RELATIVE_PATH);
-  const content = await readFileIfExists(settingsPath);
-  if (content === null) return { exists: false, migrated: false };
-
-  const version = readTopLevelYamlScalar(content, 'version');
-  if (version !== '1') {
-    if (reportExisting) {
-      output.write(`Настройки уже есть: ${SETTINGS_RELATIVE_PATH}\n`);
-      if (version !== '2') {
-        output.write('Автомиграция не выполнена: безопасно поддерживается только переход version: 1 → version: 2.\n');
-      }
-    }
-    return { exists: true, migrated: false, version };
+function migrateSettingsContent(content) {
+  let raw = {};
+  try {
+    const parsed = parseYaml(content);
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) raw = parsed;
+  } catch {
+    // Некорректный YAML пересобирается из defaults; в TTY все отсутствующие значения будут запрошены.
   }
 
-  const migratedSettings = migrateSettingsV1(content);
-  await writeFileAtomically(settingsPath, formatSettings(migratedSettings));
-  output.write(`Мигрированы настройки ${SETTINGS_RELATIVE_PATH}: version: 1 → version: 2.\n`);
-  return { exists: true, migrated: true, version: '2' };
-}
+  const settings = structuredClone(DEFAULT_SETTINGS);
+  const missingKeys = new Set();
+  const transfer = (key, value, validator, setter) => {
+    if (validator(value)) setter(value);
+    else missingKeys.add(key);
+  };
+  const oneOf = values => value => values.includes(value);
+  const bool = value => typeof value === 'boolean';
+  const positiveInt = value => Number.isInteger(value) && value > 0;
+  const score = value => Number.isInteger(value) && value >= 1 && value <= 100;
+
+  const legacyDefaults = objectValue(raw.defaults);
+  const orhestra = objectValue(raw.orhestra);
+  transfer('orhestra.mode', orhestra.mode, oneOf(['automatic', 'manual']), value => { settings.orhestra.mode = value; });
+  const steps = normalizeStoredOrhestraSteps(orhestra.steps);
+  transfer('orhestra.steps', steps, value => Array.isArray(value), value => { settings.orhestra.steps = value; });
+
+  const aim = objectValue(raw.aim);
+  transfer('aim.mode', aim.mode, oneOf(['automatic', 'manual']), value => { settings.aim.mode = value; });
+
+  const explore = objectValue(raw.explore);
+  const legacyStrict = legacyDefaults.strict;
+  transfer('explore.strict', explore.strict ?? legacyStrict, bool, value => { settings.explore.strict = value; });
+  transfer(
+    'explore.decisionMode',
+    explore.decision_mode ?? legacyDefaults.decision_mode,
+    oneOf(['autonomous', 'recommend_and_ask', 'ask_each_time']),
+    value => { settings.explore.decisionMode = value; }
+  );
 
-function migrateSettingsV1(content) {
-  const defaultsStrict = readLegacyBoolean(content, 'defaults', 'strict', false);
-  const decisionMode = readLegacyEnum(
-    content,
-    'defaults',
-    'decision_mode',
-    ['autonomous', 'recommend_and_ask', 'ask_each_time'],
-    DEFAULT_SETTINGS.explore.decisionMode
+  const plan = objectValue(raw.plan);
+  transfer('plan.strict', plan.strict ?? legacyStrict, bool, value => { settings.plan.strict = value; });
+  transfer('plan.review', plan.review ?? plan.meta_review, bool, value => { settings.plan.review = value; });
+  transfer(
+    'plan.size',
+    plan.size ?? legacyDefaults.plan_size,
+    oneOf(['normal', 'short', 'ask_each_time']),
+    value => { settings.plan.size = value; }
+  );
+  transfer(
+    'plan.decisionMode',
+    plan.decision_mode ?? legacyDefaults.decision_mode,
+    oneOf(['autonomous', 'recommend_and_ask', 'ask_each_time']),
+    value => { settings.plan.decisionMode = value; }
+  );
+  transfer(
+    'plan.testStrategy',
+    plan.test_strategy ?? legacyDefaults.test_strategy,
+    oneOf(['after_each_phase', 'tdd_each_phase', 'end_of_plan', 'ask_each_time']),
+    value => { settings.plan.testStrategy = value; }
+  );
+  transfer(
+    'plan.loggingStrategy',
+    plan.logging_strategy ?? legacyDefaults.logging_strategy,
+    oneOf(['debug_precise', 'standard', 'ask_each_time']),
+    value => { settings.plan.loggingStrategy = value; }
   );
-  const reviewAgents = structuredClone(DEFAULT_REVIEW_AGENTS);
-  reviewAgents.code_quality.mode = readLegacyBoolean(
-    content,
-    'review',
-    'include_code_quality',
-    true
-  ) ? 'always' : 'off';
 
-  return {
-    ...structuredClone(DEFAULT_SETTINGS),
-    explore: {
-      strict: defaultsStrict,
-      decisionMode
-    },
-    plan: {
-      strict: defaultsStrict,
-      size: readLegacyEnum(
-        content,
-        'defaults',
-        'plan_size',
-        ['normal', 'short', 'ask_each_time'],
-        DEFAULT_SETTINGS.plan.size
-      ),
-      decisionMode,
-      testStrategy: readLegacyEnum(
-        content,
-        'defaults',
-        'test_strategy',
-        ['after_each_phase', 'tdd_each_phase', 'end_of_plan', 'ask_each_time'],
-        DEFAULT_SETTINGS.plan.testStrategy
-      ),
-      loggingStrategy: readLegacyEnum(
-        content,
-        'defaults',
-        'logging_strategy',
-        ['debug_precise', 'standard', 'ask_each_time'],
-        DEFAULT_SETTINGS.plan.loggingStrategy
-      )
-    },
-    planPolish: {
-      strict: defaultsStrict
-    },
-    review: {
-      agents: reviewAgents
-    },
-    discoverAutomations: {
-      includePlans: readLegacyBoolean(content, 'automate', 'include_plans', false)
-    }
-  };
-}
+  const planReview = objectValue(raw['plan-review']);
+  transfer('planReview.threshold', planReview.threshold, score, value => { settings.planReview.threshold = value; });
+  transferAgentSettings({
+    rawAgents: objectValue(planReview.agents),
+    settingsAgents: settings.planReview.agents,
+    definitions: PLAN_REVIEW_AGENT_DEFINITIONS,
+    prefix: 'planReview.agents',
+    missingKeys
+  });
 
-function readLegacyBoolean(content, section, key, fallback) {
-  const value = readNestedYamlScalar(content, section, key);
-  if (value === 'true') return true;
-  if (value === 'false') return false;
-  return fallback;
-}
+  const planPolish = objectValue(raw['plan-polish']);
+  transfer('planPolish.limit', planPolish.limit, positiveInt, value => { settings.planPolish.limit = value; });
+
+  const review = objectValue(raw.review);
+  transferAgentSettings({
+    rawAgents: objectValue(review.agents),
+    settingsAgents: settings.review.agents,
+    definitions: REVIEW_AGENT_DEFINITIONS,
+    prefix: 'review.agents',
+    missingKeys
+  });
+  if (typeof review.include_code_quality === 'boolean' && !objectValue(review.agents).code_quality) {
+    settings.review.agents.code_quality.mode = review.include_code_quality ? 'always' : 'off';
+    missingKeys.delete('review.agents.code_quality.mode');
+  }
+
+  const sendReview = objectValue(raw['send-review']);
+  transfer(
+    'sendReview.closePreviousReviews',
+    sendReview.close_previous_reviews,
+    bool,
+    value => { settings.sendReview.closePreviousReviews = value; }
+  );
+  const discoverAutomations = objectValue(raw['discover-automations']);
+  const legacyAutomate = objectValue(raw.automate);
+  transfer(
+    'discoverAutomations.includePlans',
+    discoverAutomations.include_plans ?? legacyAutomate.include_plans,
+    bool,
+    value => { settings.discoverAutomations.includePlans = value; }
+  );
 
-function readLegacyEnum(content, section, key, allowedValues, fallback) {
-  const value = readNestedYamlScalar(content, section, key);
-  return allowedValues.includes(value) ? value : fallback;
+  return {
+    settings,
+    missingKeys,
+    version: Number.isInteger(raw.version) ? raw.version : null
+  };
 }
 
-function readTopLevelYamlScalar(content, key) {
-  for (const line of content.replace(/^\uFEFF/, '').split(/\r?\n/)) {
-    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/);
-    if (match?.[1] === key) return normalizeYamlScalar(match[2]);
+function transferAgentSettings({ rawAgents, settingsAgents, definitions, prefix, missingKeys }) {
+  const allowedModes = ['always', 'auto', 'off'];
+  const allowedClaudeModels = CLAUDE_REVIEW_MODEL_CHOICES.map(choice => choice.value);
+  const allowedCodexModels = CODEX_REVIEW_MODEL_CHOICES.map(choice => choice.value);
+  for (const definition of definitions) {
+    const configured = objectValue(rawAgents[definition.key]);
+    const model = objectValue(configured.model);
+    if (allowedModes.includes(configured.mode)) settingsAgents[definition.key].mode = configured.mode;
+    else missingKeys.add(`${prefix}.${definition.key}.mode`);
+    if (allowedClaudeModels.includes(model.claude)) settingsAgents[definition.key].model.claude = model.claude;
+    else missingKeys.add(`${prefix}.${definition.key}.model.claude`);
+    if (allowedCodexModels.includes(model.codex)) settingsAgents[definition.key].model.codex = model.codex;
+    else missingKeys.add(`${prefix}.${definition.key}.model.codex`);
   }
-  return null;
 }
 
-function readNestedYamlScalar(content, section, key) {
-  let currentSection = null;
-  for (const line of content.replace(/^\uFEFF/, '').split(/\r?\n/)) {
-    if (/^\s*(?:#.*)?$/.test(line)) continue;
-
-    const sectionMatch = line.match(/^([A-Za-z0-9_-]+):\s*(?:#.*)?$/);
-    if (sectionMatch) {
-      currentSection = sectionMatch[1];
-      continue;
-    }
-
-    if (/^\S/.test(line)) {
-      currentSection = null;
-      continue;
+function normalizeStoredOrhestraSteps(value) {
+  if (!Array.isArray(value) || value.length === 0) return null;
+  const steps = [];
+  for (const step of value) {
+    if (!step || typeof step !== 'object' || Array.isArray(step)) return null;
+    if (typeof step.id !== 'string' || step.id.length === 0) return null;
+    if (typeof step.skill !== 'string' || step.skill.length === 0) return null;
+    if (step.enabled !== undefined && typeof step.enabled !== 'boolean') return null;
+    if (step.args !== undefined && typeof step.args !== 'string') return null;
+    const normalized = {
+      id: step.id,
+      skill: step.skill,
+      enabled: step.enabled !== false,
+      args: step.args ?? ''
+    };
+    const onFailure = objectValue(step.on_failure);
+    if (Object.keys(onFailure).length > 0) {
+      if (typeof onFailure.skill !== 'string' || onFailure.skill.length === 0) return null;
+      if (onFailure.args !== undefined && typeof onFailure.args !== 'string') return null;
+      if (!Array.isArray(onFailure.then) || !onFailure.then.every(item => typeof item === 'string')) return null;
+      if (onFailure.max_cycles !== undefined && (!Number.isInteger(onFailure.max_cycles) || onFailure.max_cycles <= 0)) return null;
+      normalized.onFailure = {
+        skill: onFailure.skill,
+        args: onFailure.args ?? '',
+        then: onFailure.then,
+        maxCycles: onFailure.max_cycles ?? 5
+      };
     }
-
-    if (currentSection !== section) continue;
-    const valueMatch = line.match(/^ {2}([A-Za-z0-9_-]+):\s*(.*?)\s*$/);
-    if (valueMatch?.[1] === key) return normalizeYamlScalar(valueMatch[2]);
+    steps.push(normalized);
   }
-  return null;
+  return steps;
 }
 
-function normalizeYamlScalar(value) {
-  const withoutComment = value.replace(/\s+#.*$/, '').trim();
-  if (
-    withoutComment.length >= 2
-    && ((withoutComment.startsWith('"') && withoutComment.endsWith('"'))
-      || (withoutComment.startsWith("'") && withoutComment.endsWith("'")))
-  ) {
-    return withoutComment.slice(1, -1);
-  }
-  return withoutComment;
+function objectValue(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
 
 async function writeFileAtomically(filePath, content) {
@@ -996,8 +1282,8 @@ ${onFailureThen}
       # Строка аргументов передаётся скиллу как часть текущего вызова.
       args: ${JSON.stringify(step.args ?? '')}${onFailure}`;
   }).join('\n');
-  const reviewAgents = REVIEW_AGENT_DEFINITIONS.map(agent => {
-    const configured = settings.review.agents[agent.key] ?? DEFAULT_REVIEW_AGENTS[agent.key];
+  const formatAgents = (definitions, configuredAgents, defaults) => definitions.map(agent => {
+    const configured = configuredAgents[agent.key] ?? defaults[agent.key];
     return `    # ${agent.description}
     # ${agent.auto}
     ${agent.key}:
@@ -1009,8 +1295,14 @@ ${onFailureThen}
         # Модель для Codex.
         codex: ${configured.model.codex}`;
   }).join('\n\n');
+  const planReviewAgents = formatAgents(
+    PLAN_REVIEW_AGENT_DEFINITIONS,
+    settings.planReview.agents,
+    DEFAULT_PLAN_REVIEW_AGENTS
+  );
+  const reviewAgents = formatAgents(REVIEW_AGENT_DEFINITIONS, settings.review.agents, DEFAULT_REVIEW_AGENTS);
 
-  return `version: 2
+  return `version: ${SETTINGS_VERSION}
 
 orhestra:
   # Режим полного цикла eda-orhestra.
@@ -1037,6 +1329,9 @@ plan:
   # Включает кросс-CLI ревью в eda-plan.
   # true | false
   strict: ${settings.plan.strict ? 'true' : 'false'}
+  # Запускает один eda-plan-review и при необходимости один eda-plan-review-fix.
+  # true | false
+  review: ${settings.plan.review !== false ? 'true' : 'false'}
   # Задаёт размер плана.
   # normal | short | ask_each_time
   size: ${settings.plan.size}
@@ -1050,10 +1345,18 @@ plan:
   # debug_precise | standard | ask_each_time
   logging_strategy: ${settings.plan.loggingStrategy}
 
+plan-review:
+  # План готов только без обязательных findings и при score не ниже этого порога.
+  # 1..100
+  threshold: ${settings.planReview.threshold}
+  # Каждая проверка имеет собственный режим запуска и модели для обеих сред.
+  agents:
+${planReviewAgents}
+
 plan-polish:
-  # Включает кросс-CLI ревью в eda-plan-polish.
-  # true | false
-  strict: ${settings.planPolish.strict ? 'true' : 'false'}
+  # Максимальное число подтверждающих review-итераций.
+  # Положительное целое число.
+  limit: ${settings.planPolish.limit}
 
 review:
   # Каждая проверка имеет собственный режим запуска и модели для обеих сред.