workflow-ai 1.1.0 → 1.3.0

package/src/runner.mjs

@@ -176,7 +176,8 @@ class Logger {
    */
   stageStart(stageId, agentId, skillId) {
     this.stats.stagesStarted++;
-    this.info(`START stage="${stageId}" agent="${agentId}" skill="${skillId}"`, stageId);
+    const ticketInfo = this.context && this.context.ticket_id ? ` ticket="${this.context.ticket_id}"` : "";
+    this.info(`START stage="${stageId}" agent="${agentId}" skill="${skillId}"${ticketInfo}`, stageId);
   }
 
   /**
@@ -1406,6 +1407,38 @@ class StageExecutor {
 class PipelineRunner {
   constructor(config, args) {
     this.config = config;
+    
+    // Validate manual-gate stages in pipeline.yaml at startup
+    if (config.pipeline && config.pipeline.stages) {
+      for (const [stageId, stage] of Object.entries(config.pipeline.stages)) {
+        if (stage.type === 'manual-gate') {
+          // Validate goto.approved
+          if (!stage.goto || !stage.goto.approved) {
+            throw new Error(`pipeline.yaml validation error in stage '${stageId}' (type: manual-gate): missing required 'goto.approved'`);
+          }
+          
+          // Validate goto.rejected
+          if (!stage.goto || !stage.goto.rejected) {
+            throw new Error(`pipeline.yaml validation error in stage '${stageId}' (type: manual-gate): missing required 'goto.rejected'`);
+          }
+          
+          // Validate poll_interval_ms if present
+          if (stage.poll_interval_ms !== undefined) {
+            if (typeof stage.poll_interval_ms !== 'number' || stage.poll_interval_ms < 100) {
+              throw new Error(`pipeline.yaml validation error in stage '${stageId}' (type: manual-gate): poll_interval_ms must be a number >= 100`);
+            }
+          }
+          
+          // Validate timeout_seconds if present
+          if (stage.timeout_seconds !== undefined) {
+            if (typeof stage.timeout_seconds !== 'number' || stage.timeout_seconds <= 0) {
+              throw new Error(`pipeline.yaml validation error in stage '${stageId}' (type: manual-gate): timeout_seconds must be a number > 0`);
+            }
+          }
+        }
+      }
+    }
+    
     this.args = args;
     this.pipeline = config.pipeline;
     this.context = { ...this.pipeline.context };
@@ -1464,36 +1497,266 @@ class PipelineRunner {
     }
   }
 
-  /**
-   * Выполняет встроенный стейдж типа update-counter:
-   * инкрементирует счётчик и возвращает статус для goto-перехода.
-   *
-   * Конфигурация стейджа:
-   *   type: update-counter
-   *   counter: <name>   — имя счётчика
-   *   max: <number>     — максимальное значение (опционально)
-   *   goto:
-   *     default: <stage>           — следующий стейдж
-   *     max_reached: <stage>       — стейдж при достижении max
-   */
-  executeUpdateCounter(stageId, stage) {
-    const counterName = stage.counter;
-    if (!counterName) {
-      throw new Error(`Stage "${stageId}" has type update-counter but no counter specified`);
-    }
+   /**
+    * Вычисляет детерминированный идентификатор шага для approval-файла.
+    * Формат: {ticket_id}_{stageId}_{attempt}
+    *
+    * @param {Object} context - Контекст выполнения пайплайна
+    * @param {string} [context.ticket_id] - ID тикета (может быть undefined)
+    * @param {string} stageId - Идентификатор стадии
+    * @param {Object} counters - Счётчики выполнения
+    * @param {number} [counters.task_attempts] - Номер попытки выполнения (0 если не задано)
+    * @returns {string} Детерминированный step_id
+    */
+   computeStepId(context, stageId, counters) {
+     const ticketId = context.ticket_id || 'no-ticket';
+     const attempt = counters.task_attempts ?? 0;
+     return `${ticketId}_${stageId}_${attempt}`;
+   }
+
+    /**
+     * Создаёт approval-файл со статусом "pending" (идемпотентно).
+     * Если файл уже существует — не перезаписывает, возвращает его содержимое.
+     *
+     * @param {string} filePath - Путь к approval-файлу (абсолютный)
+     * @param {Object} payload - Данные для approval-файла
+     * @param {string} payload.step_id - Идентификатор шага (должен совпадать с именем файла)
+     * @param {string} payload.ticket_id - ID тикета
+     * @param {string} payload.stage_id - ID стадии
+     * @param {number} payload.attempt - Номер попытки
+     * @param {Object} [payload.context_snapshot] - Снапшот контекста (опционально)
+     * @returns {Promise<Object>} Объект approval-файла (прочитанный или созданный)
+     * @throws {Error} При ошибке создания директории или записи файла
+     */
+    async writeApprovalPending(filePath, payload) {
+      // Создаём директорию заранее (recursive, безопасно)
+      const dir = path.dirname(filePath);
+      await fs.promises.mkdir(dir, { recursive: true });
+
+      // Формируем данные approval-файла
+      const now = new Date().toISOString();
+      const approvalData = {
+        step_id: payload.step_id,
+        ticket_id: payload.ticket_id,
+        stage_id: payload.stage_id,
+        attempt: payload.attempt,
+        status: 'pending',
+        created_at: now,
+        updated_at: now,
+        decided_by: null,
+        comment: null,
+        context_snapshot: payload.context_snapshot || {}
+      };
 
-    this.counters[counterName] = (this.counters[counterName] || 0) + 1;
-    const value = this.counters[counterName];
+      const content = JSON.stringify(approvalData, null, 2);
 
-    if (this.logger) {
-      this.logger.info(`Counter "${counterName}" incremented to ${value}`, stageId);
+      // Атомарно создаём файл с флагом 'wx' (fail if exists)
+      try {
+        const handle = await fs.promises.open(filePath, 'wx');
+        await handle.write(content);
+        await handle.close();
+        return approvalData;
+      } catch (err) {
+        if (err.code === 'EEXIST') {
+          // Файл уже был создан (например, при recovery) — читаем и возвращаем
+          const existing = await fs.promises.readFile(filePath, 'utf8');
+          return JSON.parse(existing);
+        }
+        throw err;
+      }
+    }
+
+    /**
+     * Читает approval-файл и парсит его как JSON.
+     *
+     * @param {string} filePath - Путь к approval-файлу (абсолютный)
+     * @returns {Promise<Object|null>} Объект approval-файла или null если файл не существует
+     * @throws {Error} При невалидном JSON — с сообщением "corrupt approval file at {path}: {parse error}"
+     */
+    async readApprovalFile(filePath) {
+      try {
+        const content = await fs.promises.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+      } catch (err) {
+        if (err.code === 'ENOENT') {
+          return null;
+        }
+        if (err instanceof SyntaxError) {
+          throw new Error(`corrupt approval file at ${filePath}: ${err.message}`);
+        }
+        // Перебрасываем другие ошибки (например, fs-ошибки) без изменений
+        throw err;
+      }
+    }
+
+    /**
+     * Выполняет встроенный стейдж типа update-counter:
+     * инкрементирует счётчик и возвращает статус для goto-перехода.
+     *
+     * Конфигурация стейджа:
+     *   type: update-counter
+     *   counter: <name>   — имя счётчика
+     *   max: <number>     — максимальное значение (опционально)
+     *   goto:
+     *     default: <stage>           — следующий стейдж
+     *     max_reached: <stage>       — стейдж при достижении max
+     */
+    executeUpdateCounter(stageId, stage) {
+      const counterName = stage.counter;
+      if (!counterName) {
+        throw new Error(`Stage "${stageId}" has type update-counter but no counter specified`);
+      }
+
+      this.counters[counterName] = (this.counters[counterName] || 0) + 1;
+      const value = this.counters[counterName];
+
+      if (this.logger) {
+        this.logger.info(`Counter "${counterName}" incremented to ${value}`, stageId);
+      }
+
+      const max = stage.max;
+      const status = (max && value >= max) ? 'max_reached' : 'default';
+
+      return { status, result: { counter: counterName, value } };
     }
 
-    const max = stage.max;
-    const status = (max && value >= max) ? 'max_reached' : 'default';
+    /**
+     * Выполняет встроенный стейдж типа manual-gate: создаёт approval-файл
+     * и ждёт решения (approved/rejected) через polling файловой системы.
+     *
+     * Конфигурация стейджа:
+     *   type: manual-gate
+     *   poll_interval_ms: <number>  — интервал опроса в мс (опц., default 2000)
+     *   timeout_seconds: <number>   — таймаут в секундах (опц., default null)
+     *   goto:
+     *     approved: <stage>         — обязательный, при одобрении
+     *     rejected: <stage>         — обязательный, при отклонении
+     *     timeout: <stage>          — опц., при истечении таймаута
+     *     aborted: <stage>          — опц., при остановке runner'а
+     *
+     * @param {string} stageId - ID стадии
+     * @param {object} stage - конфигурация стадии
+     * @returns {Promise<{status: 'approved'|'rejected'|'timeout'|'aborted', result: object}>}
+     */
+    async executeManualGate(stageId, stage) {
+      const stepId = this.computeStepId(this.context, stageId, this.counters);
+      const filePath = path.join(this.projectRoot, '.workflow', 'approvals', `${stepId}.json`);
+
+      const payload = {
+        step_id: stepId,
+        ticket_id: this.context.ticket_id || 'no-ticket',
+        stage_id: stageId,
+        attempt: this.counters.task_attempts || 0,
+        context_snapshot: { ...this.context }
+      };
 
-    return { status, result: { counter: counterName, value } };
-  }
+      const existing = await this.writeApprovalPending(filePath, payload);
+
+      // Если файл уже был и статус уже resolved — сразу возвращаем результат (recovery)
+      if (existing.status === 'approved' || existing.status === 'rejected') {
+        if (this.logger) {
+          this.logger.info(
+            `[${stageId}] manual-gate: already ${existing.status} by ${existing.decided_by || 'unknown'}${existing.comment ? `, comment="${existing.comment}"` : ''}`,
+            stageId
+          );
+        }
+        return {
+          status: existing.status,
+          result: {
+            step_id: stepId,
+            decided_by: existing.decided_by,
+            comment: existing.comment
+          }
+        };
+      }
+
+      // Создан новый pending-файл
+      if (this.logger) {
+        this.logger.info(`[${stageId}] manual-gate: created pending approval at ${filePath}`, stageId);
+      }
+
+      const pollIntervalMs = stage.poll_interval_ms || 2000;
+      const timeoutSeconds = stage.timeout_seconds || null;
+      const startTime = Date.now();
+
+      // Polling-цикл
+      while (this.running) {
+        await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+
+        // Проверка остановки runner'а
+        if (!this.running) {
+          if (this.logger) {
+            this.logger.warn(`[${stageId}] manual-gate: aborted (runner stopped)`, stageId);
+          }
+          return { status: 'aborted', result: { step_id: stepId } };
+        }
+
+        // Проверка таймаута
+        if (timeoutSeconds !== null) {
+          const elapsed = (Date.now() - startTime) / 1000;
+          if (elapsed >= timeoutSeconds) {
+            if (this.logger) {
+              this.logger.warn(`[${stageId}] manual-gate: timeout after ${timeoutSeconds}s, no decision`, stageId);
+            }
+            return { status: 'timeout', result: { step_id: stepId } };
+          }
+        }
+
+        // Читаем текущее состояние файла
+        let data;
+        try {
+          data = await this.readApprovalFile(filePath);
+        } catch (err) {
+          // Corrupt JSON — пробрасываем ошибку для goto.error
+          throw err;
+        }
+
+        if (data && data.status === 'approved') {
+          if (this.logger) {
+            this.logger.info(
+              `[${stageId}] manual-gate: approved by ${data.decided_by || 'unknown'}${data.comment ? `, comment="${data.comment}"` : ''}`,
+              stageId
+            );
+          }
+          return {
+            status: 'approved',
+            result: {
+              step_id: stepId,
+              decided_by: data.decided_by,
+              comment: data.comment
+            }
+          };
+        }
+
+        if (data && data.status === 'rejected') {
+          if (this.logger) {
+            this.logger.info(
+              `[${stageId}] manual-gate: rejected by ${data.decided_by || 'unknown'}${data.comment ? `, comment="${data.comment}"` : ''}`,
+              stageId
+            );
+          }
+          return {
+            status: 'rejected',
+            result: {
+              step_id: stepId,
+              decided_by: data.decided_by,
+              comment: data.comment
+            }
+          };
+        }
+
+        // DEBUG-лог polling (оставляем только если нужен)
+        if (this.logger && this.logger.level === 'debug') {
+          this.logger.debug(`[${stageId}] manual-gate: polling, current status=pending`, stageId);
+        }
+      }
+
+      // Выход по this.running = false
+      if (this.logger) {
+        this.logger.warn(`[${stageId}] manual-gate: aborted (runner stopped)`, stageId);
+      }
+      return { status: 'aborted', result: { step_id: stepId } };
+    }
 
   /**
    * Запускает основной цикл выполнения
@@ -1528,16 +1791,18 @@ class PipelineRunner {
           throw new Error(`Stage not found: ${this.currentStage}`);
         }
 
-        let result;
+         let result;
 
-        // Встроенный тип стейджа: update-counter — инкрементирует счётчик без вызова агента
-        if (stage.type === 'update-counter') {
-          result = this.executeUpdateCounter(this.currentStage, stage);
-        } else {
-          this.currentExecutor = new StageExecutor(this.config, this.context, this.counters, {}, this.fileGuard, this.logger, this.projectRoot);
-          result = await this.currentExecutor.execute(this.currentStage);
-          this.currentExecutor = null;
-        }
+         // Встроенные типы стейджа — выполняются без вызова внешних агентов
+         if (stage.type === 'update-counter') {
+           result = this.executeUpdateCounter(this.currentStage, stage);
+         } else if (stage.type === 'manual-gate') {
+           result = await this.executeManualGate(this.currentStage, stage);
+         } else {
+           this.currentExecutor = new StageExecutor(this.config, this.context, this.counters, {}, this.fileGuard, this.logger, this.projectRoot);
+           result = await this.currentExecutor.execute(this.currentStage);
+           this.currentExecutor = null;
+         }
 
         this.logger.info(`Stage ${this.currentStage} completed with status: ${result.status}`, 'PipelineRunner');
 
@@ -1843,6 +2108,22 @@ function validateConfig(config) {
         errors.push(`Stage "${stageId}" references non-existent agent: ${resolvedAgent}`);
       }
 
+      // Валидация для manual-gate стадии
+      if (stage.type === 'manual-gate') {
+        if (!stage.goto || !stage.goto.approved) {
+          errors.push(`Stage "${stageId}" has type manual-gate but missing required goto.approved`);
+        }
+        if (!stage.goto || !stage.goto.rejected) {
+          errors.push(`Stage "${stageId}" has type manual-gate but missing required goto.rejected`);
+        }
+        if (stage.poll_interval_ms !== undefined && (typeof stage.poll_interval_ms !== 'number' || stage.poll_interval_ms < 100)) {
+          errors.push(`Stage "${stageId}" has invalid poll_interval_ms: must be a number >= 100`);
+        }
+        if (stage.timeout_seconds !== undefined && (typeof stage.timeout_seconds !== 'number' || stage.timeout_seconds <= 0)) {
+          errors.push(`Stage "${stageId}" has invalid timeout_seconds: must be a number > 0`);
+        }
+      }
+
       if (stage.goto) {
         for (const [status, transition] of Object.entries(stage.goto)) {
           if (status === 'default') continue;

package/src/scripts/check-conditions.js

@@ -46,10 +46,10 @@ function checkCondition(condition) {
 
   switch (type) {
     case 'file_exists':
-      return fs.existsSync(path.join(PROJECT_DIR, value));
+      return fs.existsSync(path.isAbsolute(value) ? value : path.join(PROJECT_DIR, value));
 
     case 'file_not_exists':
-      return !fs.existsSync(path.join(PROJECT_DIR, value));
+      return !fs.existsSync(path.isAbsolute(value) ? value : path.join(PROJECT_DIR, value));
 
     case 'tasks_completed': {
       if (!value || (Array.isArray(value) && value.length === 0)) return true;

package/src/scripts/check-relevance.js

@@ -100,10 +100,12 @@ function findTicketInColumns(ticketId) {
 
 async function checkRelevance(ticketPath) {
   if (!fs.existsSync(ticketPath)) {
+    // file_not_found — это не ошибка скрипта (verdict=relevant — fail-safe).
+    // Не выходим с exit=1, чтобы pipeline продолжил выполнение следующего стейджа.
     return {
       verdict: "relevant",
       reason: "file_not_found",
-      error: `Ticket file not found: ${ticketPath}`,
+      warning: `Ticket file not found: ${ticketPath}`,
     };
   }
 

package/src/scripts/get-next-id.js

@@ -1,36 +1,102 @@
 #!/usr/bin/env node
 
+/**
+ * get-next-id.js - Универсальный генератор ID для тикетов, планов и других артефактов
+ *
+ * Режимы:
+ *
+ *   1) Одиночный префикс (legacy, для create-plan / create-report):
+ *      node get-next-id.js --prefix TASK --dir tickets
+ *      node get-next-id.js --prefix PLAN --dir plans
+ *      Вывод: { status: "success", id: "TASK-007" }
+ *
+ *   2) Карта по всем префиксам из config.yaml (для decompose-plan):
+ *      node get-next-id.js --all-from-config
+ *      Читает .workflow/config/config.yaml → task_types.*.prefix,
+ *      для каждого префикса возвращает следующий свободный номер по .workflow/tickets/.
+ *      Вывод: { status: "success", id_ranges: { TASK: 8, QA: 26, HUMAN: 2, ... } }
+ */
+
 import fs from "fs";
 import path from "path";
-import { findProjectRoot } from "../lib/find-root.mjs";
-import { printResult } from "../lib/utils.mjs";
-import { getNextId } from "../lib/operations/tickets.mjs";
+import { findProjectRoot } from "workflow-ai/lib/find-root.mjs";
+import { printResult } from "workflow-ai/lib/utils.mjs";
+import { getNextId } from "workflow-ai/lib/operations/tickets.mjs";
 
 const PROJECT_DIR = findProjectRoot();
 
 function parseArgs() {
   const args = process.argv.slice(2);
-  const result = { prefix: null, dir: null, allFromConfig: false };
+  let prefix = null;
+  let dir = null;
+  let allFromConfig = false;
+
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--prefix" && i + 1 < args.length) result.prefix = args[++i];
-    else if (args[i] === "--dir" && i + 1 < args.length) result.dir = args[++i];
-    else if (args[i] === "--all-from-config") result.allFromConfig = true;
+    if (args[i] === "--prefix" && i + 1 < args.length) {
+      prefix = args[i + 1];
+      i++;
+    } else if (args[i] === "--dir" && i + 1 < args.length) {
+      dir = args[i + 1];
+      i++;
+    } else if (args[i] === "--all-from-config") {
+      allFromConfig = true;
+    }
+  }
+
+  return { prefix, dir, allFromConfig };
+}
+
+function findMaxNumber(targetDir, prefix) {
+  let maxNum = 0;
+  const regex = new RegExp(`^${prefix}-(\\d+)\\.md$`, "i");
+
+  function scanDirectory(dir) {
+    if (!fs.existsSync(dir)) {
+      return;
+    }
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        scanDirectory(fullPath);
+      } else if (entry.isFile()) {
+        const match = entry.name.match(regex);
+        if (match) {
+          const num = parseInt(match[1], 10);
+          if (num > maxNum) {
+            maxNum = num;
+          }
+        }
+      }
+    }
   }
-  return result;
+
+  scanDirectory(targetDir);
+  return maxNum;
 }
 
 function readPrefixesFromConfig() {
   const configPath = path.join(PROJECT_DIR, ".workflow", "config", "config.yaml");
-  if (!fs.existsSync(configPath)) throw new Error("config.yaml not found");
 
-  const text = fs.readFileSync(configPath, "utf8");
-  const prefixes = [];
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`config.yaml not found: ${configPath}`);
+  }
+
+  const text = fs.readFileSync(configPath, "utf8");
   const lines = text.split(/\r?\n/);
-  let inTaskTypes = false, taskTypesIndent = -1;
+
+  const prefixes = [];
+  let inTaskTypes = false;
+  let taskTypesIndent = -1;
 
   for (const rawLine of lines) {
+    // Убрать комментарии
     const line = rawLine.replace(/\s+#.*$/, "").replace(/^#.*$/, "");
-    if (!line.trim()) continue;
+    if (line.trim() === "") continue;
+
     const indent = line.length - line.trimStart().length;
 
     if (!inTaskTypes) {
@@ -41,48 +107,85 @@ function readPrefixesFromConfig() {
       continue;
     }
 
-    if (indent <= taskTypesIndent && line.trim()) break;
+    // Вышли из секции task_types (вернулись на тот же или меньший отступ с новым ключом)
+    if (indent <= taskTypesIndent && line.trim() !== "") {
+      break;
+    }
+
     const m = line.match(/^\s*prefix\s*:\s*["']?([A-Z][A-Z0-9_]*)["']?\s*$/);
-    if (m && !prefixes.includes(m[1])) prefixes.push(m[1]);
+    if (m) {
+      const p = m[1];
+      if (!prefixes.includes(p)) {
+        prefixes.push(p);
+      }
+    }
+  }
+
+  if (prefixes.length === 0) {
+    throw new Error("No prefixes found in config.yaml → task_types.*.prefix");
   }
 
   return prefixes;
 }
 
-function resolveTargetDir(dir) {
-  if (dir === "tickets") return path.join(PROJECT_DIR, ".workflow", "tickets");
-  if (dir === "plans") return path.join(PROJECT_DIR, ".workflow", "plans");
-  return path.join(PROJECT_DIR, dir);
+async function runSinglePrefix(prefix, dir) {
+  try {
+    const nextId = await getNextId(PROJECT_DIR, prefix, { dir });
+    printResult({ status: "success", id: nextId });
+  } catch (err) {
+    console.error(err.message);
+    printResult({ status: "error", error: err.message });
+    process.exit(1);
+  }
+}
+
+async function runAllFromConfig() {
+  const prefixes = readPrefixesFromConfig();
+  const ticketsDir = path.join(PROJECT_DIR, ".workflow", "tickets");
+
+  const idRanges = {};
+  for (const prefix of prefixes) {
+    const maxNum = fs.existsSync(ticketsDir) ? findMaxNumber(ticketsDir, prefix) : 0;
+    idRanges[prefix] = maxNum + 1;
+  }
+
+  // Параллельно возвращаем JSON-строку, потому что runner workflow-ai
+  // при подстановке $context.<key> в строку instructions применяет неявный
+  // toString() — объекты превращаются в "[object Object]". Скалярная
+  // JSON-строка подставляется корректно, декомпозитор распарсит её сам.
+  printResult({
+    status: "success",
+    id_ranges: idRanges,
+    id_ranges_json: JSON.stringify(idRanges),
+  });
 }
 
 async function main() {
   const { prefix, dir, allFromConfig } = parseArgs();
 
-  try {
-    if (allFromConfig) {
-      const prefixes = readPrefixesFromConfig();
-      const idRanges = {};
-      for (const p of prefixes) {
-        const id = await getNextId(PROJECT_DIR, p);
-        const num = parseInt(id.split("-")[1], 10);
-        idRanges[p] = num;
-      }
-      const bulkResult = { status: "success", id_ranges: idRanges, id_ranges_json: JSON.stringify(idRanges) };
-      console.log("---RESULT---");
-      console.log(JSON.stringify(bulkResult, null, 2));
-      console.log("---RESULT---");
-    } else {
-      if (!prefix || !dir) {
-        throw new Error("Either --all-from-config, or both --prefix and --dir required");
-      }
-      const id = await getNextId(PROJECT_DIR, prefix);
-      printResult({ status: "success", id });
+  if (allFromConfig) {
+    try {
+      await runAllFromConfig();
+    } catch (err) {
+      console.error(err.message);
+      printResult({ status: "error", error: err.message });
+      process.exit(1);
     }
-  } catch (err) {
-    console.error(err.message);
-    printResult({ status: "error", error: err.message });
+    return;
+  }
+
+  if (!prefix || !dir) {
+    console.error("Usage:");
+    console.error("  node get-next-id.js --prefix <PREFIX> --dir <DIRECTORY>");
+    console.error("  node get-next-id.js --all-from-config");
+    printResult({
+      status: "error",
+      error: "Missing required arguments: either --all-from-config, or both --prefix and --dir",
+    });
     process.exit(1);
   }
+
+  await runSinglePrefix(prefix, dir);
 }
 
 main();