workflow-ai 1.0.64 → 1.0.65

package/src/lib/error-classifier.mjs

@@ -0,0 +1,274 @@
+import { load as loadYaml } from './js-yaml.mjs';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, join } from 'path';
+
+const STDERR_MATCH_LIMIT = 64 * 1024;
+const MATCH_TIMEOUT_MS = 100;
+const SUPPORTED_VERSION = '1.0';
+const MIN_UTC_MIDNIGHT_DELAY_MS = 30 * 60 * 1000;
+
+export class InvalidRulesConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'InvalidRulesConfigError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+function parseConfigFile(configPath) {
+  if (!existsSync(configPath)) {
+    return { common: [], agents: {} };
+  }
+  const content = readFileSync(configPath, 'utf-8');
+  const config = loadYaml(content);
+  if (!config || typeof config !== 'object') {
+    return { common: [], agents: {} };
+  }
+  return config;
+}
+
+function validateVersion(version) {
+  if (version !== SUPPORTED_VERSION) {
+    throw new InvalidRulesConfigError(
+      `Unsupported rules version: ${version}. Update runner or downgrade rules file.`
+    );
+  }
+}
+
+function compilePattern(pattern) {
+  if (!pattern) {
+    return null;
+  }
+  try {
+    return new RegExp(pattern);
+  } catch (e) {
+    throw new InvalidRulesConfigError(`Invalid regex pattern: ${pattern}. ${e.message}`);
+  }
+}
+
+function resolveExtends(agentsConfig, agentId, visited = new Set()) {
+  if (!agentsConfig[agentId]) {
+    return null;
+  }
+  if (!agentsConfig[agentId].extends) {
+    return null;
+  }
+  const extendsTarget = agentsConfig[agentId].extends;
+  if (visited.has(agentId)) {
+    throw new InvalidRulesConfigError('chained extends not supported');
+  }
+  if (!agentsConfig[extendsTarget]) {
+    throw new InvalidRulesConfigError(`extends target '${extendsTarget}' not found`);
+  }
+  if (agentsConfig[extendsTarget].extends) {
+    throw new InvalidRulesConfigError('chained extends not supported');
+  }
+  visited.add(agentId);
+  return agentsConfig[extendsTarget].rules || [];
+}
+
+function buildRules(rulesData, compiledRules = []) {
+  if (!Array.isArray(rulesData)) {
+    return compiledRules;
+  }
+  for (const rule of rulesData) {
+    if (!rule || !rule.id || !rule.class || !rule.ttl) {
+      continue;
+    }
+    compiledRules.push({
+      id: rule.id,
+      class: rule.class,
+      ttl: rule.ttl,
+      pattern: compilePattern(rule.pattern),
+      exitCodes: rule.exit_codes === 'any' ? 'any' : (
+        Array.isArray(rule.exit_codes)
+          ? rule.exit_codes.filter(c => typeof c === 'number')
+          : []
+      ),
+    });
+  }
+  return compiledRules;
+}
+
+export function loadRules(projectRoot, configPath) {
+  const defaultPath = join(projectRoot, '.workflow/config/agent-health-rules.yaml');
+  const fullPath = configPath || defaultPath;
+  let config;
+  try {
+    config = parseConfigFile(fullPath);
+  } catch (e) {
+    if (e instanceof InvalidRulesConfigError) {
+      throw e;
+    }
+    return { common: [], agents: new Map() };
+  }
+  if (!config || typeof config !== 'object') {
+    return { common: [], agents: new Map() };
+  }
+  if (config.version) {
+    validateVersion(config.version);
+  }
+  const commonRules = buildRules(config.common || []);
+  const agents = new Map();
+  const agentsConfig = config.agents || {};
+  for (const agentId of Object.keys(agentsConfig)) {
+    const agentConfig = agentsConfig[agentId];
+    if (!agentConfig) {
+      continue;
+    }
+    const inheritedRules = resolveExtends(agentsConfig, agentId);
+    const ownRules = buildRules(agentConfig.rules || []);
+    const finalRules = [...ownRules];
+    if (inheritedRules && inheritedRules.length > 0) {
+      finalRules.push(...buildRules(inheritedRules));
+    }
+    agents.set(agentId, finalRules);
+  }
+  return { common: commonRules, agents };
+}
+
+function truncateStderr(stderr) {
+  if (!stderr || stderr.length <= STDERR_MATCH_LIMIT) {
+    return stderr;
+  }
+  const halfLimit = STDERR_MATCH_LIMIT / 2;
+  const head = stderr.slice(0, halfLimit);
+  const tail = stderr.slice(-halfLimit);
+  return head + '\n...[TRUNCATED]...\n' + tail;
+}
+
+function matchRule(rule, exitCode, truncatedStderr) {
+  const exitCodesMatch = rule.exitCodes === 'any' ||
+    rule.exitCodes.includes(exitCode);
+  if (!exitCodesMatch) {
+    return false;
+  }
+  if (!rule.pattern) {
+    return true;
+  }
+  try {
+    return rule.pattern.test(truncatedStderr);
+  } catch (e) {
+    return false;
+  }
+}
+
+function matchWithTimeout(regex, text) {
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(() => {
+      resolve(false);
+    }, MATCH_TIMEOUT_MS);
+    try {
+      const result = regex.test(text);
+      clearTimeout(timeoutId);
+      resolve(result);
+    } catch (e) {
+      clearTimeout(timeoutId);
+      resolve(false);
+    }
+  });
+}
+
+export async function classify(rules, agentId, { exitCode, stderr }) {
+  const truncatedStderr = truncateStderr(stderr);
+  const agentRules = rules.agents.get(agentId) || [];
+  for (const rule of agentRules) {
+    const matched = rule.pattern
+      ? await matchWithTimeout(rule.pattern, truncatedStderr)
+      : matchRule(rule, exitCode, truncatedStderr);
+    if (matched) {
+      return {
+        class: rule.class,
+        rule_id: rule.id,
+        ttl: rule.ttl,
+        reason: truncatedStderr,
+      };
+    }
+  }
+  for (const rule of rules.common) {
+    const matched = rule.pattern
+      ? await matchWithTimeout(rule.pattern, truncatedStderr)
+      : matchRule(rule, exitCode, truncatedStderr);
+    if (matched) {
+      return {
+        class: rule.class,
+        rule_id: rule.id,
+        ttl: rule.ttl,
+        reason: truncatedStderr,
+      };
+    }
+  }
+  return null;
+}
+
+export function parseTtl(ttl, now = Date.now()) {
+  if (ttl === 'infinite') {
+    return Number.MAX_SAFE_INTEGER;
+  }
+  const untilMatch = ttl.match(/^(\d+)d$/);
+  if (untilMatch) {
+    return now + parseInt(untilMatch[1], 10) * 24 * 60 * 60 * 1000;
+  }
+  const hourMatch = ttl.match(/^(\d+)h$/);
+  if (hourMatch) {
+    return now + parseInt(hourMatch[1], 10) * 60 * 60 * 1000;
+  }
+  const minMatch = ttl.match(/^(\d+)m$/);
+  if (minMatch) {
+    return now + parseInt(minMatch[1], 10) * 60 * 1000;
+  }
+  if (ttl === 'until_utc_midnight') {
+    const nextMidnight = new Date(now);
+    nextMidnight.setUTCHours(24, 0, 0, 0);
+    const minDelay = now + MIN_UTC_MIDNIGHT_DELAY_MS;
+    return Math.max(nextMidnight.getTime(), minDelay);
+  }
+  throw new Error(`Invalid TTL format: ${ttl}. Expected Nm, Nh, Nd, until_utc_midnight, or infinite.`);
+}
+
+export function classifySync(rules, agentId, { exitCode, stderr }) {
+  const truncatedStderr = truncateStderr(stderr);
+  const agentRules = rules.agents.get(agentId) || [];
+  for (const rule of agentRules) {
+    const matched = rule.pattern
+      ? (() => {
+          try {
+            return rule.pattern.test(truncatedStderr);
+          } catch (e) {
+            return false;
+          }
+        })()
+      : matchRule(rule, exitCode, truncatedStderr);
+    if (matched) {
+      return {
+        class: rule.class,
+        rule_id: rule.id,
+        ttl: rule.ttl,
+        reason: truncatedStderr,
+      };
+    }
+  }
+  for (const rule of rules.common) {
+    const matched = rule.pattern
+      ? (() => {
+          try {
+            return rule.pattern.test(truncatedStderr);
+          } catch (e) {
+            return false;
+          }
+        })()
+      : matchRule(rule, exitCode, truncatedStderr);
+    if (matched) {
+      return {
+        class: rule.class,
+        rule_id: rule.id,
+        ttl: rule.ttl,
+        reason: truncatedStderr,
+      };
+    }
+  }
+  return null;
+}
+

package/src/lib/test-error-classifier.mjs

@@ -0,0 +1,60 @@
+import { loadRules, classify, parseTtl, classifySync, InvalidRulesConfigError } from './error-classifier.mjs';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+
+const tmp = mkdtempSync(path.join(os.tmpdir(), 'ec-test-'));
+const configDir = path.join(tmp, '.workflow/config');
+mkdirSync(configDir, { recursive: true });
+const configPath = path.join(configDir, 'agent-health-rules.yaml');
+
+writeFileSync(configPath, `version: "1.0"
+common:
+  - id: "net-econnreset"
+    class: "transient"
+    ttl: "5m"
+    pattern: "ECONNRESET|ETIMEDOUT"
+    exit_codes: "any"
+agents:
+  qwen-code:
+    rules:
+      - id: "qwen-quota"
+        class: "unavailable"
+        ttl: "until_utc_midnight"
+        pattern: "Qwen OAuth quota exceeded"
+        exit_codes: "any"
+`);
+
+const rules = loadRules(tmp);
+console.log('loadRules result:', { commonLen: rules.common.length, agentsSize: rules.agents.size });
+
+const result1 = await classify(rules, 'qwen-code', { exitCode: 1, stderr: 'Qwen OAuth quota exceeded' });
+console.log('classify qwen-quota:', result1?.class, result1?.rule_id);
+
+const result2 = await classify(rules, 'qwen-code', { exitCode: 1, stderr: 'Some other error' });
+console.log('classify no match:', result2);
+
+const result3 = await classify(rules, 'claude-sonnet', { exitCode: 1, stderr: 'ECONNRESET' });
+console.log('classify common:', result3?.class, result3?.rule_id);
+
+const result4 = classifySync(rules, 'qwen-code', { exitCode: 1, stderr: 'Qwen OAuth quota exceeded' });
+console.log('classifySync qwen-quota:', result4?.class, result4?.rule_id);
+
+const ttl1 = parseTtl('5m');
+console.log('parseTtl 5m:', typeof ttl1, ttl1 > Date.now());
+
+const ttl2 = parseTtl('infinite');
+console.log('parseTtl infinite:', ttl2 === Number.MAX_SAFE_INTEGER);
+
+const now = new Date('2026-04-21T12:00:00Z').getTime();
+const ttl3 = parseTtl('until_utc_midnight', now);
+console.log('parseTtl until_utc_midnight:', ttl3 >= now);
+
+const ttl4 = parseTtl('1h');
+console.log('parseTtl 1h:', ttl4 > now);
+
+const ttl5 = parseTtl('1d');
+console.log('parseTtl 1d:', ttl5 > now);
+
+rmSync(tmp, { recursive: true, force: true });
+console.log('All tests passed!');

package/src/lib/test-extends.mjs

@@ -0,0 +1,58 @@
+import { loadRules, classify, classifySync } from './error-classifier.mjs';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+
+const tmp = mkdtempSync(path.join(os.tmpdir(), 'ec-test-'));
+const configDir = path.join(tmp, '.workflow/config');
+mkdirSync(configDir, { recursive: true });
+const configPath = path.join(configDir, 'agent-health-rules.yaml');
+
+writeFileSync(configPath, `version: "1.0"
+common:
+  - id: "common-test"
+    class: "transient"
+    ttl: "5m"
+    pattern: "common-error"
+    exit_codes: "any"
+agents:
+  claude-sonnet:
+    rules:
+      - id: "claude-specific"
+        class: "unavailable"
+        ttl: "10m"
+        pattern: "claude-specific-error"
+        exit_codes: "any"
+  claude-opus:
+    extends: claude-sonnet
+  kilo-glm:
+    rules:
+      - id: "kilo-own"
+        class: "misconfigured"
+        ttl: "1h"
+        pattern: "kilo-error"
+        exit_codes: "any"
+`);
+
+const rules = loadRules(tmp);
+console.log('loadRules with extends:');
+
+const opusRules = rules.agents.get('claude-opus');
+console.log('claude-opus rules (from extends):', opusRules?.length);
+console.log('claude-opus first rule:', opusRules?.[0]?.id);
+
+const glmRules = rules.agents.get('kilo-glm');
+console.log('kilo-glm rules (own):', glmRules?.length);
+console.log('kilo-glm first rule:', glmRules?.[0]?.id);
+
+const test1 = classifySync(rules, 'claude-opus', { exitCode: 1, stderr: 'claude-specific-error' });
+console.log('classify claude-opus with specific error:', test1?.class, test1?.rule_id);
+
+const test2 = classifySync(rules, 'claude-opus', { exitCode: 1, stderr: 'common-error' });
+console.log('classify claude-opus with common error:', test2?.class, test2?.rule_id);
+
+const test3 = classifySync(rules, 'kilo-glm', { exitCode: 1, stderr: 'kilo-error' });
+console.log('classify kilo-glm with own error:', test3?.class, test3?.rule_id);
+
+rmSync(tmp, { recursive: true, force: true });
+console.log('Extends tests passed!');

package/src/lib/test-version.mjs

@@ -0,0 +1,21 @@
+import { InvalidRulesConfigError } from './error-classifier.mjs';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+
+const tmp = mkdtempSync(path.join(os.tmpdir(), 'ec-test-'));
+const configDir = path.join(tmp, '.workflow/config');
+mkdirSync(configDir, { recursive: true });
+const configPath = path.join(configDir, 'agent-health-rules.yaml');
+
+writeFileSync(configPath, 'version: "2.0"\ncommon: []');
+
+try {
+  const { loadRules } = await import('./error-classifier.mjs');
+  loadRules(tmp);
+  console.log('ERROR: should have thrown');
+} catch (e) {
+  console.log('Version error works:', e.name === 'InvalidRulesConfigError', e.message.includes('2.0'));
+}
+
+rmSync(tmp, { recursive: true, force: true });

package/src/scripts/move-to-review.js

@@ -16,8 +16,6 @@ import fs from "fs";
 import path from "path";
 import { findProjectRoot } from "workflow-ai/lib/find-root.mjs";
 import {
-  parseFrontmatter,
-  serializeFrontmatter,
   printResult,
   getLastReviewStatus,
 } from "workflow-ai/lib/utils.mjs";
@@ -98,18 +96,18 @@ function moveToReview(ticketId) {
   }
 
   const content = fs.readFileSync(sourcePath, "utf8");
-  const { frontmatter, body } = parseFrontmatter(content);
 
-  frontmatter.updated_at = new Date().toISOString();
-
-  const newContent = serializeFrontmatter(frontmatter) + body;
+  // updated_at не обновляем: verify-artifacts сравнивает mtime файлов с updated_at,
+  // чтобы убедиться, что они были изменены агентом. updated_at должен сохранять момент
+  // перемещения тикета в in-progress (до начала работы агента) — иначе любой
+  // легитимно изменённый файл будет ложно отклонён (mtime_edit < updated_at_review).
 
   if (!fs.existsSync(REVIEW_DIR)) {
     fs.mkdirSync(REVIEW_DIR, { recursive: true });
   }
 
   fs.renameSync(sourcePath, targetPath);
-  fs.writeFileSync(targetPath, newContent, "utf8");
+  fs.writeFileSync(targetPath, content, "utf8");
 
   return {
     status: "moved",

package/src/scripts/reset-agent-health.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+import { loadHealth, markHealthy, unhealthy } from '../lib/agent-health-registry.mjs';
+
+const projectRoot = process.cwd();
+
+function getState() {
+  return loadHealth(projectRoot);
+}
+
+function showState() {
+  const state = getState();
+  console.log('---RESULT---');
+  console.log(JSON.stringify(state, null, 2));
+  console.log('---RESULT---');
+}
+
+function resetAgent(agentId) {
+  const state = getState();
+  const agent = state.agents[agentId];
+  
+  if (!agent) {
+    console.log(`Agent "${agentId}" not found in health registry`);
+    return;
+  }
+  
+  markHealthy(projectRoot, agentId);
+  console.log(`Reset health status for agent "${agentId}"`);
+}
+
+function resetAll() {
+  const unhealthyAgents = unhealthy(projectRoot);
+  
+  if (unhealthyAgents.length === 0) {
+    console.log('No unhealthy agents to reset');
+    return;
+  }
+  
+  const resetList = unhealthyAgents.map(a => a.agentId);
+  
+  for (const agentId of resetList) {
+    markHealthy(projectRoot, agentId);
+  }
+  
+  console.log(`Reset ${resetList.length} agent(s): ${resetList.join(', ')}`);
+}
+
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+  showState();
+} else if (args[0] === '--agent' && args[1]) {
+  resetAgent(args[1]);
+} else if (args[0] === '--all') {
+  resetAll();
+} else {
+  console.log('Usage:');
+  console.log('  node reset-agent-health.js              # Show current state');
+  console.log('  node reset-agent-health.js --agent <id> # Reset single agent');
+  console.log('  node reset-agent-health.js --all   # Reset all unhealthy');
+  process.exit(1);
+}

package/src/skills/coach/SKILL.md

@@ -127,6 +127,7 @@ ticket_prefix: COACH
 2. **Evidence-Based** — все выводы основаны на данных из завершённых тикетов, планов и логов пайплайна, а не на предположениях. **При анализе лога обязательно строй временную диаграмму ключевых событий по ID артефакта** (тикет, план, отчёт): проследи всю цепочку перемещений/изменений артефакта от первого упоминания до последнего, обращая внимание на события, отстоящие далеко друг от друга по времени, но связанные одним ID. **Антипаттерн:** прочитал начало лога (события archive/cleanup), прочитал середину (события create/decompose), но **не сопоставил** их — упустил коллизию ID или другой паттерн взаимного влияния. Перед формулированием findings задай себе вопрос: «Я проверил всю историю каждого упомянутого ID, или только последнее событие с ним?» **⚠️ Проверка фактической практики перед нормативной правкой:** если правка вводит новое правило про путь, имя, формат, расположение — **обязательно `Grep` по всему проекту** (код, конфиги, скилы, тикеты) на ключевой термин этого правила, чтобы измерить **масштаб уже существующей практики**. Один-два аномальных артефакта — не основание объявлять их новой нормой. Если фактическая практика противоположна гипотезе — гипотеза неверна, или (если стейкхолдер действительно хочет миграцию) нужен явный миграционный план и согласие на масштаб правок. Антипаттерн: получил короткий ответ стейкхолдера на развилку → принял за сильное правило → пошёл править скилы → не проверил, что в проекте 20+ артефактов уже живут по противоположному правилу. Перед каждой нормативной правкой задай себе вопрос: «Сколько уже существующих файлов/строк проекта противоречат тому, что я собираюсь записать?» Если ответ > 5 — остановись и переспроси у стейкхолдера, точно ли это миграция. **⚠️ Обязательный diff формулировок при анализе цепочки артефактов:** когда анализируешь инцидент, прошедший через несколько стадий (план → тикет → исполнение → ревью), **перед назначением виновного** обязан построчно сопоставить формулировки критериев на каждом стыке: (1) дословная строка критерия в плане, (2) дословная строка в тикете, (3) что реально проверяет assertion/тест, (4) что ревьюер проверял. Виновник — стадия, на которой произошла первая потеря семантики. Антипаттерн: прочитал план и увидел расхождение с результатом → обвинил последнюю стадию (ревьюера), не проверив, на какой промежуточной стадии формулировка была ослаблена. Гипотеза «ревьюер должен был поймать» невалидна, если ревьюер работал по формулировке тикета, а тикет уже не содержал потерянного уточнения.
 **⚠️ Антипаттерн «уход в формулировки вместо root cause»:** стейкхолдер задаёт вопрос о наблюдаемом дефекте («почему не поймали?»), а коуч анализирует текст формулировок, семантику переносов, чеклисты — вместо того чтобы ответить на прямой вопрос: какой конкретный шаг в какой конкретной стадии не выполнил конкретное физическое действие (открыть файл, посмотреть на картинку, запустить команду). Формулировки — это причина второго порядка; причина первого порядка — «агент X не сделал действие Y». Всегда начинай с причины первого порядка, потом объясняй, почему инструкции это допустили.
 **⚠️ Антипаттерн «оценка по результату вместо сверки с инструкцией»:** при анализе действия агента — **не оценивай** его «разумность» или «допустимость» по своему суждению. Вместо этого открой скил агента и **дословно сверь** действие с инструкцией. Если инструкция говорит «разбей тикет», а агент объединил шаги — это нарушение, даже если результат выглядит «приемлемо». Коуч не имеет права смягчать finding на основании того, что дефект «небольшой» или «единичный» — скил либо нарушен, либо нет.
+**⚠️ Антипаттерн «пересказ вместо цитаты» при утверждениях о коде:** перед утверждением вида «скрипт/функция X использует/читает/пишет Y» обязан открыть файл и **дословно процитировать** строку, на которой это поведение происходит. Пересказ по памяти (даже свежей) теряет операторы-fallback (`a || b`, `a ?? b`), условные ветви, ранние return'ы — те детали, которые как раз и задают реальное поведение. Источник ошибки: агент видит ключевое слово в строке, строит «достаточное» утверждение о поведении и идёт дальше. Правило: если утверждение про код войдёт в финдинг, CHG, черновик правки или ответ стейкхолдеру — строка должна быть в отчёте целиком (либо скопированной в цитату, либо явной ссылкой `file:line`, открытой и перечитанной непосредственно перед утверждением).
 3. **Итеративность** — улучшай скилы инкрементально. Маленькие точечные улучшения > масштабные переписывания.
 4. **Обратная совместимость** — улучшения не должны ломать существующие воркфлоу и интеграции.
 5. **Актуальность знаний** — активно ищи в интернете лучшие практики, фреймворки и подходы для обогащения скилов.

package/src/skills/coach/tests/cases/TC-COACH-001/current/meta.json

@@ -1,9 +1,8 @@
 {
-  "date": "2026-04-19T12:30:16.942Z",
-  "skill_sha": "3c4e051",
+  "date": "2026-04-21T08:57:32.459Z",
+  "skill_sha": "6df42d0",
   "status": "passed",
   "duration_ms": 1,
-  "l1_skipped": true,
   "per_model": {
     "claude-sonnet": {
       "passed": true,

package/src/skills/coach/tests/cases/TC-COACH-002/current/meta.json

@@ -1,9 +1,8 @@
 {
-  "date": "2026-04-19T12:30:16.947Z",
-  "skill_sha": "3c4e051",
+  "date": "2026-04-21T08:57:32.466Z",
+  "skill_sha": "6df42d0",
   "status": "passed",
   "duration_ms": 2,
-  "l1_skipped": true,
   "per_model": {
     "claude-sonnet": {
       "passed": true,

package/src/skills/decompose-gaps/tests/cases/TC-DECOMPOSE-GAPS-001/current/claude-sonnet/trial-1.md

@@ -1,49 +1,41 @@
-## Анализ gap: «Нужно исправить дефект маппинга полей»
+## Декомпозиция недочётов
 
-### Применение алгоритма scope-check
+### Обработка Gap: «Нужно исправить дефект маппинга полей»
 
-**Шаг 2a — Проверка раздела «Исключено из scope»:**
+**Выполняю проверку scope по алгоритму `algorithms/scope-check.md`:**
 
-Из контекста задачи:
+**Шаг 2a — Проверка exclusions из scope плана:**
 
-| Параметр | Значение |
-|----------|----------|
-| Gap | «Нужно исправить дефект маппинга полей» |
-| Секция плана | «Исключено из scope: исправление дефектов» |
+- `plan_exclusions = ["исправление дефектов"]`
+- Gap описывает: исправление дефекта маппинга полей
+- Сопоставление по смыслу: «исправить дефект маппинга» → подпадает под исключение «исправление дефектов»
 
-**Проверка:**
-- `plan_exclusions` = `["исправление дефектов"]`
-- Gap описывает исправление дефекта (дефект маппинга полей)
-- Gap **прямо подпадает** под исключение
-
-**Результат алгоритма:**
+**Результат проверки:**
 ```
-{
+check_scope(gap) → {
   in_scope: false,
   reason: "Gap подпадает под исключение из scope плана: 'исправление дефектов'",
   check_failed: "2a"
 }
 ```
 
----
+Тикет **не создаётся**.
 
-## Новые требования (вне scope)
+---
 
-Следующий gap **исключён** и не конвертируется в тикет:
+### Новые требования (вне scope плана)
 
-> **Gap:** «Нужно исправить дефект маппинга полей»
->
-> **Причина отклонения:** Gap scope-исключён — план явно содержит раздел «Исключено из scope: исправление дефектов». Данная работа выходит за рамки текущего плана.
->
-> **Проверка:** 2a (exclusion check)
->
-> **Рекомендация:** Оформить как отдельную инициативу или новый план, если исправление дефекта маппинга полей признаётся приоритетным.
+- **«Нужно исправить дефект маппинга полей»** — причина: gap семантически совпадает с пунктом «Исключено из scope: исправление дефектов». Исправление дефектов явно выведено за рамки плана; создание fix-тикета нарушило бы границы scope. Требует отдельного решения на уровне планирования (новый план или явное снятие исключения).
 
 ---
 
-## ---RESULT---
-
-**Тикеты созданы:** 0
-
-**Gaps, отклонённых как вне scope:** 1
-- «Нужно исправить дефект маппинга полей» — scope-исключён (проверка 2a: «Исключено из scope: исправление дефектов»)
+```
+---RESULT---
+status: default
+created_tickets: (нет)
+rejected_gaps:
+  - gap: "Нужно исправить дефект маппинга полей"
+    reason: "Вне scope — подпадает под исключение плана: 'исправление дефектов'"
+    check_failed: "2a"
+---RESULT---
+```