workflow-ai 1.1.0 → 1.2.1

package/src/lib/operations/tickets.mjs

@@ -1,12 +1,20 @@
 import { findProjectRoot } from '../find-root.mjs';
-import { parseFrontmatter, serializeFrontmatter, getLastReviewStatus, normalizePlanId } from '../utils.mjs';
+import { parseFrontmatter, serializeFrontmatter, getLastReviewStatus } from '../utils.mjs';
 import { existsSync, readdirSync, promises as fs } from 'node:fs';
 import { resolve, join } from 'node:path';
 
+// Доступные статусы
 const VALID_STATUSES = [
-  "backlog", "ready", "in-progress", "blocked", "review", "done", "archive",
+  "backlog",
+  "ready",
+  "in-progress",
+  "blocked",
+  "review",
+  "done",
+  "archive",
 ];
 
+// Таблица допустимых переходов
 const VALID_TRANSITIONS = {
   backlog: ["ready", "blocked", "done"],
   ready: ["in-progress", "review", "backlog"],
@@ -17,316 +25,406 @@ const VALID_TRANSITIONS = {
   archive: ["backlog"],
 };
 
+/**
+ * Форматирует номер с ведущими нулями (1 → 001)
+ */
 function formatNumber(num) {
   return String(num).padStart(3, '0');
 }
 
-export async function getNextId(projectRoot, type) {
+/**
+ * Находит следующий свободный ID для указанного типа тикетов
+ * @param {string} projectRoot - Корень проекта
+ * @param {string} type - Тип тикета (например, IMPL, QA)
+ * @param {object} options - Опции
+ * @param {string} [options.dir] - Опциональный override директории для сканирования (например, 'tickets', 'reports', или абсолютный путь)
+ * @returns {Promise<string>} Следующий ID в формате TYPE-NNN
+ */
+export async function getNextId(projectRoot, type, options = {}) {
+  // Если projectRoot не предоставлен, ищем его сами
   const root = projectRoot || findProjectRoot();
-  const ticketsDir = join(root, '.workflow', 'tickets');
-  if (!existsSync(ticketsDir)) return `${type}-001`;
-  const maxNum = findMaxNumber(ticketsDir, type);
-  return `${type}-${formatNumber(maxNum + 1)}`;
+
+  // Определяем директорию для сканирования
+  let targetDir;
+  if (options.dir) {
+    // Если dir указан, используем resolveTargetId-like логику
+    if (options.dir === "tickets") {
+      targetDir = join(root, '.workflow', 'tickets');
+    } else if (options.dir === "plans") {
+      targetDir = join(root, '.workflow', 'plans');
+    } else {
+      targetDir = join(root, options.dir);
+    }
+  } else {
+    // По умолчанию используем .workflow/tickets
+    targetDir = join(root, '.workflow', 'tickets');
+  }
+
+  // Если директория не существует, возвращаем первый ID
+  if (!existsSync(targetDir)) {
+    return `${type}-001`;
+  }
+
+  // Рекурсивный поиск всех файлов {TYPE}-*.md
+  const maxNum = findMaxNumber(targetDir, type);
+  const nextNum = maxNum + 1;
+  return `${type}-${formatNumber(nextNum)}`;
 }
 
+/**
+ * Рекурсивно ищет максимальный номер для файлов с заданным префиксом
+ * @param {string} targetDir - Директория для поиска
+ * @param {string} prefix - Префикс файла (например, IMPL)
+ * @returns {number} Максимальный найденный номер
+ */
 function findMaxNumber(targetDir, prefix) {
   let maxNum = 0;
   const regex = new RegExp(`^${prefix}-(\\d+)\\.md$`, "i");
+
   function scanDirectory(dir) {
-    if (!existsSync(dir)) return;
+    if (!existsSync(dir)) {
+      return;
+    }
+
     const entries = readdirSync(dir, { withFileTypes: true });
+
     for (const entry of entries) {
       const fullPath = join(dir, entry.name);
-      if (entry.isDirectory()) scanDirectory(fullPath);
-      else if (entry.isFile()) {
+
+      if (entry.isDirectory()) {
+        scanDirectory(fullPath);
+      } else if (entry.isFile()) {
         const match = entry.name.match(regex);
-        if (match) maxNum = Math.max(maxNum, parseInt(match[1], 10));
+        if (match) {
+          const num = parseInt(match[1], 10);
+          if (num > maxNum) {
+            maxNum = num;
+          }
+        }
       }
     }
   }
+
   scanDirectory(targetDir);
   return maxNum;
 }
 
+/**
+ * Определяет текущий статус тикета по расположению файла
+ */
 function getStatusFromPath(ticketId, ticketsDir) {
   for (const status of VALID_STATUSES) {
-    if (existsSync(join(ticketsDir, status, `${ticketId}.md`))) return status;
+    const statusDir = join(ticketsDir, status);
+    const expectedPath = join(statusDir, `${ticketId}.md`);
+    if (existsSync(expectedPath)) {
+      return status;
+    }
   }
   return null;
 }
 
+/**
+ * Проверяет допустимость перехода и бросает ошибку если недопустим
+ */
 function assertValidTransition(from, to) {
-  if (!VALID_STATUSES.includes(from) || !VALID_STATUSES.includes(to)) {
+  if (!VALID_STATUSES.includes(from)) {
+    throw { code: 'INVALID_TRANSITION', from, to, id: null };
+  }
+  if (!VALID_STATUSES.includes(to)) {
     throw { code: 'INVALID_TRANSITION', from, to, id: null };
   }
-  if (!VALID_TRANSITIONS[from]?.includes(to)) {
+
+  const allowedTransitions = VALID_TRANSITIONS[from] || [];
+  if (!allowedTransitions.includes(to)) {
     throw { code: 'INVALID_TRANSITION', from, to, id: null };
   }
 }
 
+/**
+ * Перемещает тикет между колонками канбан-доски
+ * @param {string} projectRoot - Корень проекта
+ * @param {string} id - ID тикета
+ * @param {string} target - Целевой статус
+ * @returns {{from: string, to: string, path: string}} Результат перемещения
+ */
 export async function moveTicket(projectRoot, id, target) {
   const root = projectRoot || findProjectRoot();
   const ticketsDir = join(root, '.workflow', 'tickets');
+
+  // Найти текущий статус тикета
   const from = getStatusFromPath(id, ticketsDir);
-  if (!from) throw { code: 'INVALID_TRANSITION', from: null, to: target, id };
+  if (!from) {
+    throw { code: 'INVALID_TRANSITION', from: null, to: target, id };
+  }
+
+  // Проверить допустимость перехода
   assertValidTransition(from, target);
 
   const sourcePath = join(ticketsDir, from, `${id}.md`);
   const targetDir = join(ticketsDir, target);
   const targetPath = join(targetDir, `${id}.md`);
 
-  let content = await fs.readFile(sourcePath, 'utf8');
-  let { frontmatter, body } = parseFrontmatter(content);
+  // Чтение файла тикета
+  let content;
+  try {
+    content = await fs.readFile(sourcePath, 'utf8');
+  } catch (e) {
+    throw new Error(`Не удалось прочитать файл: ${e.message}`);
+  }
+
+  // Парсинг frontmatter
+  let frontmatter, body;
+  try {
+    ({ frontmatter, body } = parseFrontmatter(content));
+  } catch (e) {
+    throw new Error(e.message);
+  }
+
+  // Обновление frontmatter
   const now = new Date().toISOString();
   frontmatter.updated_at = now;
-  if (target === "done" && from !== "done") frontmatter.completed_at = now;
-  if (target === "done" && from === "review" && getLastReviewStatus(content) === null) {
+
+  // Если переход в done, добавляем completed_at
+  if (target === "done" && from !== "done") {
+    frontmatter.completed_at = now;
+  }
+
+  // Fallback: если тикет идёт в done из review, но агент не записал секцию "## Ревью" — дописываем
+  if (
+    target === "done" &&
+    from === "review" &&
+    getLastReviewStatus(content) === null
+  ) {
     const date = now.slice(0, 16).replace("T", " ");
-    body = body.trimEnd() + `\n## Ревью\n\n| Дата | Статус | Самари |\n|------|--------|--------|\n| ${date} | ✅ passed | Pipeline fallback |\n`;
+    const reviewSection = `\n## Ревью\n\n| Дата | Статус | Самари |\n|------|--------|--------|\n| ${date} | ✅ passed | Pipeline fallback: агент не записал секцию ревью |\n`;
+    body = body.trimEnd() + "\n" + reviewSection;
+  }
+
+  // Если переход из blocked, удаляем blocked_reason
+  if (from === "blocked" && frontmatter.blocked_reason) {
+    delete frontmatter.blocked_reason;
   }
-  if (from === "blocked" && frontmatter.blocked_reason) delete frontmatter.blocked_reason;
 
+  // Сериализация нового контента
   const newContent = serializeFrontmatter(frontmatter) + body;
-  if (!existsSync(targetDir)) await fs.mkdir(targetDir, { recursive: true });
-  await fs.rename(sourcePath, targetPath);
-  await fs.writeFile(targetPath, newContent, 'utf8');
+
+  // Создание целевой директории если не существует
+  if (!existsSync(targetDir)) {
+    await fs.mkdir(targetDir, { recursive: true });
+  }
+
+  // Перемещение файла
+  try {
+    await fs.rename(sourcePath, targetPath);
+  } catch (e) {
+    throw new Error(`Не удалось переместить файл: ${e.message}`);
+  }
+
+  // Запись обновлённого контента
+  try {
+    await fs.writeFile(targetPath, newContent, 'utf8');
+  } catch (e) {
+    throw new Error(`Не удалось записать файл: ${e.message}`);
+  }
+
   return { from, to: target, path: targetPath };
 }
 
+/**
+ * Проверяет одно условие (condition) тикета
+ */
 function checkCondition(projectRoot, condition) {
   const { type, value } = condition;
+
   switch (type) {
-    case 'file_exists': return existsSync(join(projectRoot, value));
-    case 'file_not_exists': return !existsSync(join(projectRoot, value));
-    case 'tasks_completed':
+    case 'file_exists':
+      return existsSync(join(projectRoot, value));
+
+    case 'file_not_exists':
+      return !existsSync(join(projectRoot, value));
+
+    case 'tasks_completed': {
       if (!value || (Array.isArray(value) && value.length === 0)) return true;
       const ids = Array.isArray(value) ? value : [value];
       const doneDir = join(projectRoot, '.workflow', 'tickets', 'done');
       const archiveDir = join(projectRoot, '.workflow', 'tickets', 'archive');
-      return ids.every(tid => existsSync(join(doneDir, `${tid}.md`)) || existsSync(join(archiveDir, `${tid}.md`)));
-    case 'date_after': return new Date() > new Date(value);
-    case 'date_before': return new Date() < new Date(value);
-    case 'manual_approval': return false;
-    default: return true;
+      return ids.every(taskId =>
+        existsSync(join(doneDir, `${taskId}.md`)) ||
+        existsSync(join(archiveDir, `${taskId}.md`))
+      );
+    }
+
+    case 'date_after':
+      return new Date() > new Date(value);
+
+    case 'date_before':
+      return new Date() < new Date(value);
+
+    case 'manual_approval':
+      return false;
+
+    default:
+      return true;
   }
 }
 
+/**
+ * Проверяет зависимости тикета
+ */
 function checkDependencies(projectRoot, dependencies) {
   if (!dependencies || dependencies.length === 0) return true;
   const doneDir = join(projectRoot, '.workflow', 'tickets', 'done');
   const archiveDir = join(projectRoot, '.workflow', 'tickets', 'archive');
   return dependencies.every(depId =>
-    existsSync(join(doneDir, `${depId}.md`)) || existsSync(join(archiveDir, `${depId}.md`))
+    existsSync(join(doneDir, `${depId}.md`)) ||
+    existsSync(join(archiveDir, `${depId}.md`))
   );
 }
 
+/**
+ * Создаёт новый тикет в tickets/backlog/ с автоинкрементированным ID
+ * @param {string} projectRoot - Корень проекта
+ * @param {object} data - Данные для frontmatter (title, type, priority, tags, context, etc.)
+ * @returns {Promise<{id: string, path: string}>} Созданный ID и абсолютный путь
+ */
 export async function createTicket(projectRoot, data) {
   const root = projectRoot || findProjectRoot();
   const ticketsDir = join(root, '.workflow', 'tickets');
   const backlogDir = join(ticketsDir, 'backlog');
+
+  // 1. Получить следующий ID
   const type = data.type ?? 'impl';
   const id = await getNextId(root, type);
+
+  // 2. Сформировать frontmatter
   const frontmatter = {
-    id, title: data.title ?? '', priority: data.priority ?? 3, type,
+    id,
+    title: data.title ?? '',
+    priority: data.priority ?? 3,
+    type: data.type ?? 'impl',
     required_capabilities: data.required_capabilities ?? [],
-    created_at: new Date().toISOString(), updated_at: new Date().toISOString(), completed_at: '',
-    parent_plan: data.parent_plan ?? '', parent_task: data.parent_task ?? '',
-    dependencies: data.dependencies ?? [], conditions: data.conditions ?? [],
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    completed_at: '',
+    parent_plan: data.parent_plan ?? '',
+    parent_task: data.parent_task ?? '',
+    dependencies: data.dependencies ?? [],
+    conditions: data.conditions ?? [],
     context: data.context ?? { files: [], references: [], notes: '' },
-    complexity: data.complexity ?? 'medium', tags: data.tags ?? [],
+    complexity: data.complexity ?? 'medium',
+    tags: data.tags ?? []
   };
-  if (data.type === 'human') frontmatter.executor_type = 'human';
-  if (!existsSync(backlogDir)) await fs.mkdir(backlogDir, { recursive: true });
-  const path = join(backlogDir, `${id}.md`);
-  const content = serializeFrontmatter(frontmatter) + '\n## Описание\n\n\n## Критерии готовности (Definition of Done)\n\n- [ ] \n';
-  await fs.writeFile(path, content, 'utf8');
-  return { id, path };
-}
 
-/**
- * Проверяет, заполнен ли раздел результатов (Summary) в тикете
- */
-function hasFilledResult(body) {
-  const resultSectionRegex = /^##\s*(Результат выполнения|Result)\s*$/m;
-  const sectionStart = body.search(resultSectionRegex);
-  if (sectionStart === -1) return false;
-  const nextSectionRegex = /^##\s+/gm;
-  nextSectionRegex.lastIndex = sectionStart + 1;
-  const nextSectionMatch = nextSectionRegex.exec(body);
-  const sectionEnd = nextSectionMatch ? nextSectionMatch.index : body.length;
-  const sectionContent = body.substring(sectionStart, sectionEnd);
-  const summaryRegex = /^###\s*(Summary|Что сделано)\s*$/m;
-  const summaryStart = sectionContent.search(summaryRegex);
-  if (summaryStart === -1) return false;
-  const nextSubsectionRegex = /^###\s+/gm;
-  nextSubsectionRegex.lastIndex = summaryStart + 1;
-  const nextSubsectionMatch = nextSubsectionRegex.exec(sectionContent);
-  const summaryEnd = nextSubsectionMatch ? nextSubsectionMatch.index : sectionContent.length;
-  const summaryContent = sectionContent.substring(summaryStart, summaryEnd);
-  const withoutComments = summaryContent.replace(/<!--[\s\S]*?-->/g, '').trim();
-  return withoutComments.length > 0;
-}
+  // 3. Добавить executor_type если type === 'human'
+  if (data.type === 'human') {
+    frontmatter.executor_type = 'human';
+  }
 
-function filterByPlan(tickets, planId) {
-  if (!planId) return tickets;
-  return tickets.filter(t => normalizePlanId(t.frontmatter.parent_plan) === planId);
-}
+  // 4. Записать файл в backlog/
+  if (!existsSync(backlogDir)) {
+    await fs.mkdir(backlogDir, { recursive: true });
+  }
 
-function sortTickets(tickets) {
-  return tickets.sort((a, b) => {
-    const pa = a.frontmatter.priority || 999, pb = b.frontmatter.priority || 999;
-    if (pa !== pb) return pa - pb;
-    const da = new Date(a.frontmatter.created_at || '9999-12-31');
-    const db = new Date(b.frontmatter.created_at || '9999-12-31');
-    return da - db;
-  });
-}
+  const path = join(backlogDir, `${id}.md`);
+  const content = serializeFrontmatter(frontmatter) + '\n## Описание\n\n\n## Критерии готовности (Definition of Done)\n\n- [ ] \n';
 
-function isTicketEligible(projectRoot, ticket, checkDuplicates = [], currentDir = null) {
-  const { frontmatter, id } = ticket;
-  if (frontmatter.type === 'human') return false;
-  if (!checkDependencies(projectRoot, frontmatter.dependencies || [])) return false;
-  const conditions = frontmatter.conditions || [];
-  if (!conditions.every(c => checkCondition(projectRoot, c))) return false;
-
-  // Проверка дубликатов - исключаем тикет если он находится в других директориях
-  // checkDuplicates может быть true (исключить все кроме currentDir) или false/[] (не проверять)
-  if (checkDuplicates === true || (Array.isArray(checkDuplicates) && checkDuplicates.length > 0)) {
-    const allDirs = ['ready', 'done', 'in-progress', 'review', 'blocked'].filter(d => d !== currentDir).map(d =>
-      join(projectRoot, '.workflow', 'tickets', d));
-    if (allDirs.some(dir => existsSync(join(dir, `${id}.md`)))) return false;
+  try {
+    await fs.writeFile(path, content, 'utf8');
+  } catch (e) {
+    throw new Error(`Не удалось записать файл: ${e.message}`);
   }
-  return true;
+
+  return { id, path };
 }
 
 /**
- * Выбирает следующий доступный тикет (все статусы: found, in_review, completed_in_progress, in_progress, empty)
+ * Выбирает следующий доступный тикет из директории ready/
  * @param {string} projectRoot - Корень проекта
- * @param {string} planId - ID плана для фильтрации
- * @returns {Promise<object>} Результат выбора
+ * @returns {Promise<object>} {ticket} если найден, или {empty: true, reason}
  */
 export async function pickNext(projectRoot) {
   const root = projectRoot || findProjectRoot();
-  const ticketsDir = join(root, '.workflow', 'tickets');
-  const readyDir = join(ticketsDir, 'ready');
-  const reviewDir = join(ticketsDir, 'review');
-  const inProgressDir = join(ticketsDir, 'in-progress');
-
-  // 1. ready/ тикеты
-  const readyFiles = existsSync(readyDir) ? readdirSync(readyDir).filter(f => f.endsWith('.md') && f !== '.gitkeep.md') : [];
-  const readyTickets = [];
-  for (const file of readyFiles) {
-    try {
-      const content = await fs.readFile(join(readyDir, file), 'utf8');
-      const { frontmatter } = parseFrontmatter(content);
-      readyTickets.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter, filePath: join(readyDir, file) });
-    } catch (e) {}
-  }
-  if (readyTickets.length === 0) {
+  const readyDir = join(root, '.workflow', 'tickets', 'ready');
+
+  // 1. Проверка пустой ready/
+  if (!existsSync(readyDir)) {
     return { empty: true, reason: 'no_ready_tickets' };
   }
-  const eligibleReady = readyTickets.filter(t => isTicketEligible(root, t, true, 'ready'));
-  if (eligibleReady.length > 0) {
-    const selected = sortTickets(eligibleReady)[0];
-    return { ticket: { id: selected.id, ...selected.frontmatter, path: selected.filePath } };
-  }
-  return { empty: true, reason: 'no_eligible_tickets' };
-}
 
-/**
- * Оригинальная функция pickNext (только ready/) - для совместимости
- */
-export async function pickNextEffective(projectRoot, planId) {
-  const root = projectRoot || findProjectRoot();
-  const ticketsDir = join(root, '.workflow', 'tickets');
-  const readyDir = join(ticketsDir, 'ready');
-  const reviewDir = join(ticketsDir, 'review');
-  const inProgressDir = join(ticketsDir, 'in-progress');
-
-  // 1. ready/
-  const readyFiles = existsSync(readyDir) ? readdirSync(readyDir).filter(f => f.endsWith('.md') && f !== '.gitkeep.md') : [];
-  const readyTickets = [];
-  for (const file of readyFiles) {
-    try {
-      const content = await fs.readFile(join(readyDir, file), 'utf8');
-      const { frontmatter } = parseFrontmatter(content);
-      readyTickets.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter, filePath: join(readyDir, file) });
-    } catch (e) {}
-  }
-  const eligibleReady = readyTickets.filter(t => isTicketEligible(root, t, true, 'ready'));
-  if (eligibleReady.length > 0) {
-    const selected = sortTickets(eligibleReady)[0];
-    return { status: 'found', ticket_id: selected.id, priority: selected.frontmatter.priority,
-      title: selected.frontmatter.title, type: selected.frontmatter.type,
-      required_capabilities: JSON.stringify(selected.frontmatter.required_capabilities || []) };
+  const files = readdirSync(readyDir).filter(f => f.endsWith('.md') && f !== '.gitkeep.md');
+  if (files.length === 0) {
+    return { empty: true, reason: 'no_ready_tickets' };
   }
 
-  // 2. review/
-  const reviewFiles = existsSync(reviewDir) ? readdirSync(reviewDir).filter(f => f.endsWith('.md') && f !== '.gitkeep.md') : [];
-  const reviewTickets = [];
-  for (const file of reviewFiles) {
+  const tickets = [];
+
+  // 2. Чтение и парсинг тикетов
+  for (const file of files) {
+    const filePath = join(readyDir, file);
     try {
-      const content = await fs.readFile(join(reviewDir, file), 'utf8');
+      const content = await fs.readFile(filePath, 'utf8');
       const { frontmatter } = parseFrontmatter(content);
-      reviewTickets.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter, filePath: join(reviewDir, file) });
-    } catch (e) {}
-  }
-  if (reviewTickets.length > 0) {
-    const eligibleReview = reviewTickets.filter(t => isTicketEligible(root, t, true, 'review'));
-    if (eligibleReview.length > 0) {
-      const selected = sortTickets(eligibleReview)[0];
-      return { status: 'in_review', ticket_id: selected.id, priority: selected.frontmatter.priority,
-        title: selected.frontmatter.title, type: selected.frontmatter.type,
-        required_capabilities: JSON.stringify(selected.frontmatter.required_capabilities || []) };
-    }
-  }
 
-  // 3. in-progress/ завершённые
-  const inProgressFiles = existsSync(inProgressDir) ? readdirSync(inProgressDir).filter(f => f.endsWith('.md') && f !== '.gitkeep.md') : [];
-  const completedInProgress = [];
-  for (const file of inProgressFiles) {
-    try {
-      const content = await fs.readFile(join(inProgressDir, file), 'utf8');
-      const { frontmatter, body } = parseFrontmatter(content);
-      if (hasFilledResult(body)) {
-        completedInProgress.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter, filePath: join(inProgressDir, file) });
-      }
-    } catch (e) {}
-  }
-  if (completedInProgress.length > 0) {
-    const eligibleCompleted = completedInProgress.filter(t => isTicketEligible(root, t, true, 'in-progress'));
-    if (eligibleCompleted.length > 0) {
-      const selected = sortTickets(eligibleCompleted)[0];
-      return { status: 'completed_in_progress', ticket_id: selected.id,
-        required_capabilities: JSON.stringify(selected.frontmatter.required_capabilities || []) };
+      tickets.push({
+        id: frontmatter.id || file.replace('.md', ''),
+        frontmatter,
+        path: filePath
+      });
+    } catch (e) {
+      // Пропускаем битые файлы
     }
   }
 
-  // 4. in-progress/ незавершённые
-  const allInProgress = [];
-  for (const file of inProgressFiles) {
-    try {
-      const content = await fs.readFile(join(inProgressDir, file), 'utf8');
-      const { frontmatter, body } = parseFrontmatter(content);
-      if (!hasFilledResult(body)) {
-        allInProgress.push({ id: frontmatter.id || file.replace('.md', ''), frontmatter, filePath: join(inProgressDir, file) });
-      }
-    } catch (e) {}
-  }
-  if (allInProgress.length > 0) {
-    const eligibleInProgress = allInProgress.filter(t => isTicketEligible(root, t, true, 'in-progress'));
-    if (eligibleInProgress.length > 0) {
-      const selected = sortTickets(eligibleInProgress)[0];
-      return { status: 'in_progress', ticket_id: selected.id, priority: selected.frontmatter.priority,
-        title: selected.frontmatter.title, type: selected.frontmatter.type,
-        required_capabilities: JSON.stringify(selected.frontmatter.required_capabilities || []) };
-    }
+  // 3. Фильтрация по условиям и зависимостям
+  const eligibleTickets = tickets.filter(ticket => {
+    const { frontmatter, id, path: filePath } = ticket;
+
+    // Пропускаем human-тики
+    if (frontmatter.type === 'human') return false;
+
+    // Проверка зависимостей
+    const depsMet = checkDependencies(root, frontmatter.dependencies || []);
+    if (!depsMet) return false;
+
+    // Проверка условий
+    const conditions = frontmatter.conditions || [];
+    const conditionsMet = conditions.every(c => checkCondition(root, c));
+    if (!conditionsMet) return false;
+
+    // Проверка на дубликаты (тикет не должен быть в in-progress, review, done и т.д.)
+    const otherDirs = ['done', 'in-progress', 'review', 'blocked'].map(d =>
+      join(root, '.workflow', 'tickets', d)
+    );
+    const duplicate = otherDirs.some(dir =>
+      existsSync(join(dir, `${id}.md`))
+    );
+    if (duplicate) return false;
+
+    return true;
+  });
+
+  if (eligibleTickets.length === 0) {
+    return { empty: true, reason: 'no_eligible_tickets' };
   }
 
-  // 5. пусто
-  return { status: 'empty', reason: 'No tickets in ready/' };
-}
+  // 4. Сортировка: приоритет (меньше = важнее), затем created_at (старые первые)
+  eligibleTickets.sort((a, b) => {
+    const priorityA = a.frontmatter.priority || 999;
+    const priorityB = b.frontmatter.priority || 999;
+    if (priorityA !== priorityB) return priorityA - priorityB;
 
-/**
- * Оригинальная функция pickNext (только ready/) - для совместимости со старыми test
- */
+    const dateA = new Date(a.frontmatter.created_at || '9999-12-31');
+    const dateB = new Date(b.frontmatter.created_at || '9999-12-31');
+    return dateA - dateB;
+  });
+
+  // 5. Возврат первого подходящего
+  const selected = eligibleTickets[0];
+  return {
+    ticket: {
+      id: selected.id,
+      ...selected.frontmatter,
+      path: selected.path
+    }
+  };
+}