workflow-ai 1.0.64 → 1.0.66

package/configs/agent-health-rules.yaml

@@ -0,0 +1,75 @@
+version: "1.0"
+
+common:
+  - id: "net-econnreset"
+    class: "transient"
+    ttl: "5m"
+    pattern: "ECONNRESET|ETIMEDOUT|EAI_AGAIN|connection reset by peer|socket hang up"
+    exit_codes: "any"
+  - id: "http-5xx-transient"
+    class: "transient"
+    ttl: "5m"
+    pattern: "\\b(502|503|504)\\b.*(Bad Gateway|Service Unavailable|Gateway Timeout)"
+    exit_codes: "any"
+  - id: "http-auth"
+    class: "misconfigured"
+    ttl: "1h"
+    pattern: "\\b(401|403)\\b|Unauthorized|Forbidden|API key (not found|invalid|missing)"
+    exit_codes: "any"
+
+agents:
+  qwen-code:
+    rules:
+      - id: "qwen-quota"
+        class: "unavailable"
+        ttl: "until_utc_midnight"
+        pattern: "Qwen OAuth quota exceeded|qwen.*quota.*exceed|Daily limit.*reached"
+        exit_codes: "any"
+      - id: "qwen-oauth-required"
+        class: "misconfigured"
+        ttl: "1h"
+        pattern: "Please run `qwen login`|qwen OAuth flow"
+        exit_codes: "any"
+
+  claude-sonnet:
+    rules:
+      - id: "claude-overloaded"
+        class: "unavailable"
+        ttl: "10m"
+        pattern: "overloaded_error|\\b529\\b|Overloaded"
+        exit_codes: "any"
+      - id: "claude-rate-limit"
+        class: "unavailable"
+        ttl: "1h"
+        pattern: "rate_limit_error|\\b429\\b.*rate|usage limit"
+        exit_codes: "any"
+
+  claude-opus:
+    extends: claude-sonnet
+
+  kilo-free:
+    rules:
+      - id: "kilo-free-tier-exhausted"
+        class: "unavailable"
+        ttl: "until_utc_midnight"
+        pattern: "free tier.*exhaust|daily limit|too many requests"
+        exit_codes: "any"
+
+  kilo-deepseek:
+    rules:
+      - id: "kilo-deepseek-provider-down"
+        class: "transient"
+        ttl: "15m"
+        pattern: "deepseek.*unavailable|upstream error"
+        exit_codes: "any"
+
+  kilo-glm:
+    rules:
+      - id: "zai-usage-limit"
+        class: "unavailable"
+        ttl: "5h"
+        pattern: "Usage limit reached for \\d+ hour|api\\.z\\.ai.*\"statusCode\":429|AI_APICallError.*z\\.ai"
+        exit_codes: "any"
+
+  kilo-glm-air:
+    extends: kilo-glm

package/configs/pipeline.yaml

@@ -64,42 +64,42 @@ pipeline:
 
     kilo-code:
       command: "kilo"
-      args: ["-m", "kilo/kilo-auto/free", "--agent", "orchestrator", "run"]
+      args: ["-m", "kilo/kilo-auto/free", "--agent", "orchestrator", "--print-logs", "--log-level", "ERROR", "run"]
       workdir: "."
       capabilities: [text]
       description: "Kilo мульти-режимный (architect, code, debug)"
 
     kilo-glm:
       command: "kilo"
-      args: ["-m", "zai/glm-5.1", "--agent", "code", "run"]
+      args: ["-m", "zai/glm-5.1", "--agent", "code", "--print-logs", "--log-level", "ERROR", "run"]
       workdir: "."
       capabilities: [text]
       description: "Kilo GLM"
 
     kilo-glm-air:
       command: "kilo"
-      args: ["-m", "zai/glm-4.5-air", "--agent", "code", "run"]
+      args: ["-m", "zai/glm-4.5-air", "--agent", "code", "--print-logs", "--log-level", "ERROR", "run"]
       workdir: "."
       capabilities: [text]
       description: "Kilo GLM air"
 
     kilo-deepseek:
       command: "kilo"
-      args: ["-m", "deepseek/deepseek-reasoner", "--agent", "code", "run"]
+      args: ["-m", "deepseek/deepseek-reasoner", "--agent", "code", "--print-logs", "--log-level", "ERROR", "run"]
       workdir: "."
       capabilities: [text]
       description: "Kilo deepseek"
 
     kilo-minimax:
       command: "kilo"
-      args: ["-m", "kilo/minimax/minimax-m2.7", "--agent", "code", "run"]
+      args: ["-m", "kilo/minimax/minimax-m2.7", "--agent", "code", "--print-logs", "--log-level", "ERROR", "run"]
       workdir: "."
       capabilities: [text]
       description: "Kilo minimax"
 
     kilo-free:
       command: "kilo"
-      args: ["-m", "kilo/kilo-auto/free", "--agent", "code", "run"]
+      args: ["-m", "kilo/kilo-auto/free", "--agent", "code", "--print-logs", "--log-level", "ERROR", "run"]
       workdir: "."
       capabilities: [text]
       description: "Kilo free"
@@ -350,7 +350,7 @@ pipeline:
     # -------------------------------------------------------------------------
     decompose-plan:
       description: "Декомпозировать план на тикеты"
-      agents: [claude-sonnet, kilo-glm, kilo-deepseek]
+      agents: [claude-sonnet, kilo-glm]
       skill: decompose-plan
       instructions: "Декомпозируй план .workflow/$context.plan_file на тикеты. ID тикетов бери ТОЛЬКО из JSON-карты id_ranges_json=$context.id_ranges_json — это стартовые номера по префиксам в формате {\"PREFIX\":N_start,...}, уже выделенные стадией allocate-ticket-ids. Распарси JSON, используй значения как есть. НЕ вызывай get-next-id.js и НЕ изобретай номера самостоятельно. Подробности: см. шаг 9.0 в workflows/decompose.md. При наличии $context.atomicity_failures — учти их при декомпозиции: исправь неатомарные тикеты."
       goto:
@@ -593,6 +593,17 @@ pipeline:
             ticket_id: "$context.ticket_id"
             attempt: "$counter.task_attempts"
             target: review
+        # Runner возвращает status=blocked при no_capable_agent / attempts_exhausted
+        # (resolveAgent в runner.mjs, строка ~926). Направляем тикет сразу в blocked/,
+        # минуя move-to-review → verify-artifacts → increment-task-attempts: иначе
+        # тикет крутится 6 итераций вхолостую (execute-task не может его взять,
+        # verify-artifacts фейлится с пустым result, счётчик достигает max → blocked
+        # всё равно). Прямой маршрут экономит ~6 пустых итераций на тикет.
+        blocked:
+          stage: move-ticket
+          params:
+            ticket_id: "$context.ticket_id"
+            target: blocked
         error:
           stage: move-to-review
           params:
@@ -728,6 +739,10 @@ pipeline:
           stage: analyze-report
           params:
             report_id: "$result.report_id"
+        # blocked означает, что required_capabilities из контекста (от предыдущего
+        # тикета) не покрыты ни одним агентом create-report. Это не фатально —
+        # завершаем пайплайн, отчёт не создан, но данные не теряются.
+        blocked: end
         error:
           stage: increment-create-report-attempts
 
@@ -758,6 +773,8 @@ pipeline:
           params:
             gaps: "$result.gaps"
             report_id: "$context.report_id"
+        # blocked по тем же причинам, что и в create-report — завершаем пайплайн.
+        blocked: end
         error:
           stage: increment-analyze-report-attempts
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workflow-ai",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "description": "AI Agent Workflow Coordinator — kanban-based pipeline for AI coding agents",
   "type": "module",
   "bin": {

package/src/init.mjs

@@ -357,7 +357,7 @@ export function initProject(targetPath = process.cwd(), options = {}) {
     errors: []
   };
   
-  // Step 1: Create .workflow/ structure (16 directories)
+  // Step 1: Create .workflow/ structure (directories)
   const directories = [
     'tickets/backlog',
     'tickets/ready',
@@ -371,13 +371,21 @@ export function initProject(targetPath = process.cwd(), options = {}) {
     'logs',
     'templates',
     'src/skills',
-    'tests/skills'
+    'tests/skills',
+    'state'
   ];
 
   for (const dir of directories) {
     ensureDir(join(workflowRoot, dir));
   }
-  result.steps.push('Created .workflow/ directory structure (16 directories)');
+  result.steps.push(`Created .workflow/ directory structure (${directories.length} directories)`);
+
+   // Create .gitkeep in .workflow/tests/skills/
+   // FIX-9: Ensure .gitkeep exists for tests/skills directory
+   const testsSkillsGitkeep = join(workflowRoot, 'tests', 'skills', '.gitkeep');
+   if (!existsSync(testsSkillsGitkeep)) {
+     writeFileSync(testsSkillsGitkeep, '');
+   }
 
   // Step 2: Ensure global dir and create skill junctions
   const globalDir = getGlobalDir();
@@ -432,6 +440,15 @@ export function initProject(targetPath = process.cwd(), options = {}) {
   updateGitignore(projectRoot);
   result.steps.push('Updated .gitignore with .workflow/logs/');
 
+  // Step 10: Copy agent-health-rules.yaml to .workflow/config/
+  const agentHealthRulesSrc = join(packageRoot, 'configs', 'agent-health-rules.yaml');
+  const agentHealthRulesDest = join(workflowRoot, 'config', 'agent-health-rules.yaml');
+  if (existsSync(agentHealthRulesSrc)) {
+    ensureDir(dirname(agentHealthRulesDest));
+    copyFileSync(agentHealthRulesSrc, agentHealthRulesDest);
+    result.steps.push('Copied agent-health-rules.yaml → .workflow/config/');
+  }
+
   return result;
 }
 

package/src/lib/agent-health-registry.mjs

@@ -0,0 +1,245 @@
+import fs from 'fs';
+import path from 'path';
+import { createLogger } from './logger.mjs';
+import { parseTtl } from './error-classifier.mjs';
+
+const HEALTH_FILE = '.workflow/state/agent-health.json';
+const LOCK_FILE = '.workflow/state/agent-health.json.lock';
+const SUPPORTED_VERSION = '1.0';
+const MAX_LOCK_RETRIES = 5;
+const LOCK_TIMEOUT_MS = 2000;
+const LOCK_BACKOFFS = [100, 200, 400, 800, 1600];
+
+const logger = createLogger();
+
+export class AgentHealthLockError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AgentHealthLockError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+function getHealthFilePath(projectRoot) {
+  return path.join(projectRoot, HEALTH_FILE);
+}
+
+function getLockFilePath(projectRoot) {
+  return path.join(projectRoot, LOCK_FILE);
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function parseTimestamp(isoString) {
+  if (!isoString) return null;
+  const date = new Date(isoString);
+  return isNaN(date.getTime()) ? null : date.getTime();
+}
+
+function readHealthFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return { version: SUPPORTED_VERSION, updated_at: null, agents: {} };
+  }
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(content);
+    if (!data || typeof data !== 'object') {
+      logger.warn(`agent-health-registry: corrupted JSON in ${filePath}, returning empty state`);
+      return { version: SUPPORTED_VERSION, updated_at: null, agents: {} };
+    }
+    return {
+      version: data.version || SUPPORTED_VERSION,
+      updated_at: data.updated_at || null,
+      agents: data.agents || {}
+    };
+  } catch (e) {
+    logger.warn(`agent-health-registry: corrupted JSON in ${filePath}, returning empty state`);
+    return { version: SUPPORTED_VERSION, updated_at: null, agents: {} };
+  }
+}
+
+function writeHealthFileAtomic(filePath, data, lockFilePath, projectRoot) {
+  const tmpPath = filePath + '.tmp';
+  const dirPath = path.dirname(filePath);
+  ensureDir(dirPath);
+
+  const startTime = Date.now();
+  for (let attempt = 0; attempt < MAX_LOCK_RETRIES; attempt++) {
+    const elapsed = Date.now() - startTime;
+    if (elapsed >= LOCK_TIMEOUT_MS) {
+      throw new AgentHealthLockError(`Failed to acquire lock within ${LOCK_TIMEOUT_MS}ms`);
+    }
+
+    const backoff = LOCK_BACKOFFS[attempt];
+    const remaining = LOCK_TIMEOUT_MS - elapsed;
+    const sleepTime = Math.min(backoff, remaining);
+
+    if (attempt > 0) {
+      if (sleepTime > 0) {
+        const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+        const start = Date.now();
+        while (Date.now() - start < sleepTime) {
+          // busy wait
+        }
+      }
+    }
+
+    try {
+      fs.openSync(lockFilePath, 'wx');
+    } catch (e) {
+      if (e.code === 'EEXIST') {
+        continue;
+      }
+      throw e;
+    }
+
+    try {
+      const content = JSON.stringify(data, null, 2);
+      fs.writeFileSync(tmpPath, content, 'utf-8');
+      fs.renameSync(tmpPath, filePath);
+      return;
+    } finally {
+      try {
+        fs.unlinkSync(lockFilePath);
+      } catch (e) {
+        // ignore lock cleanup errors
+      }
+    }
+  }
+
+  throw new AgentHealthLockError(`Failed to acquire lock after ${MAX_LOCK_RETRIES} attempts`);
+}
+
+export function loadHealth(projectRoot, now = Date.now()) {
+  const filePath = getHealthFilePath(projectRoot);
+  const data = readHealthFile(filePath);
+  pruneExpired(projectRoot, now);
+  return { agents: data.agents };
+}
+
+export function markUnhealthy(projectRoot, agentId, options) {
+  const { class: agentClass, rule_id, ttl, reason } = options;
+  const filePath = getHealthFilePath(projectRoot);
+  const lockPath = getLockFilePath(projectRoot);
+
+  const existing = readHealthFile(filePath);
+  const currentTime = new Date().toISOString();
+
+  let untilMs;
+  const now = Date.now();
+  if (typeof ttl === 'number') {
+    // Legacy: numeric milliseconds offset
+    untilMs = now + ttl;
+  } else if (typeof ttl === 'string') {
+    // String TTL: 'until_utc_midnight', '1h', '5m', '1d', 'infinite', etc.
+    try {
+      untilMs = parseTtl(ttl, now);
+    } catch {
+      untilMs = now + 5 * 60 * 1000;
+    }
+  } else {
+    untilMs = now + 5 * 60 * 1000;
+  }
+
+  const untilIso = new Date(untilMs).toISOString();
+
+  existing.agents[agentId] = {
+    status: 'unhealthy',
+    class: agentClass,
+    rule_id: rule_id || null,
+    reason: reason || null,
+    marked_at: currentTime,
+    until: untilIso
+  };
+  existing.updated_at = currentTime;
+
+  writeHealthFileAtomic(filePath, existing, lockPath, projectRoot);
+}
+
+export function markHealthy(projectRoot, agentId) {
+  const filePath = getHealthFilePath(projectRoot);
+  const lockPath = getLockFilePath(projectRoot);
+
+  const existing = readHealthFile(filePath);
+
+  if (existing.agents[agentId]) {
+    delete existing.agents[agentId];
+    existing.updated_at = new Date().toISOString();
+    writeHealthFileAtomic(filePath, existing, lockPath, projectRoot);
+  }
+}
+
+export function isHealthy(projectRoot, agentId, now = Date.now()) {
+  const filePath = getHealthFilePath(projectRoot);
+  const data = readHealthFile(filePath);
+  const agent = data.agents[agentId];
+
+  if (!agent) {
+    return true;
+  }
+
+  if (agent.status !== 'unhealthy') {
+    return true;
+  }
+
+  const untilMs = parseTimestamp(agent.until);
+  if (untilMs === null) {
+    return true;
+  }
+
+  return now >= untilMs;
+}
+
+export function unhealthy(projectRoot, now = Date.now()) {
+  const filePath = getHealthFilePath(projectRoot);
+  const data = readHealthFile(filePath);
+  const result = [];
+
+  for (const [agentId, agent] of Object.entries(data.agents)) {
+    if (agent.status !== 'unhealthy') {
+      continue;
+    }
+    const untilMs = parseTimestamp(agent.until);
+    if (untilMs !== null && now < untilMs) {
+      result.push({
+        agentId,
+        class: agent.class,
+        rule_id: agent.rule_id,
+        reason: agent.reason,
+        until: agent.until
+      });
+    }
+  }
+
+  return result;
+}
+
+export function pruneExpired(projectRoot, now = Date.now()) {
+  const filePath = getHealthFilePath(projectRoot);
+  const lockPath = getLockFilePath(projectRoot);
+
+  const existing = readHealthFile(filePath);
+  let changed = false;
+
+  for (const [agentId, agent] of Object.entries(existing.agents)) {
+    if (agent.status !== 'unhealthy') {
+      continue;
+    }
+    const untilMs = parseTimestamp(agent.until);
+    if (untilMs !== null && now >= untilMs) {
+      delete existing.agents[agentId];
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    existing.updated_at = new Date().toISOString();
+    writeHealthFileAtomic(filePath, existing, lockPath, projectRoot);
+  }
+}

package/src/lib/agent-spawner.mjs

@@ -2,6 +2,7 @@
 
 import { spawn, execSync } from 'child_process';
 import path from 'path';
+import { loadRules, scanStderrForFatalRule } from './error-classifier.mjs';
 
 const ResultParser = {
   STATUS_ALIASES: {
@@ -149,13 +150,21 @@ export async function spawnAgent(agentConfig, prompt, options = {}) {
     stageId = 'unknown',
     skillId = null,
     projectRoot = process.cwd(),
-    currentChildRef = null
+    currentChildRef = null,
+    agentId = null,
+    healthRules = null
   } = options;
 
   return new Promise((resolve, reject) => {
     const args = [...agentConfig.args];
     const finalPrompt = prompt;
 
+    // Для онлайн-детекции фатальных stderr-паттернов
+    const rules = agentId
+      ? (healthRules || (() => { try { return loadRules(projectRoot); } catch { return null; } })())
+      : null;
+    const hasAgentRules = Boolean(rules && agentId && rules.agents.get(agentId)?.length);
+
     const useShell = process.platform === 'win32' && agentConfig.command !== 'node';
     const useStdin = useShell && finalPrompt.includes('\n');
 
@@ -196,14 +205,20 @@ export async function spawnAgent(agentConfig, prompt, options = {}) {
     let stdout = '';
     let stderr = '';
     let timedOut = false;
+    let earlyKilled = false;
+    let lastScanSize = 0;
 
-    const timeoutId = setTimeout(() => {
-      timedOut = true;
+    const killChild = () => {
       if (process.platform === 'win32' && child.pid) {
         try { execSync(`taskkill /pid ${child.pid} /T /F`, { stdio: 'pipe' }); } catch {}
       } else {
-        child.kill('SIGTERM');
+        try { child.kill('SIGTERM'); } catch {}
       }
+    };
+
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      killChild();
       if (logger) {
         logger.timeout(stageId, timeout);
       }
@@ -243,6 +258,32 @@ export async function spawnAgent(agentConfig, prompt, options = {}) {
     child.stderr.on('data', (data) => {
       stderr += data.toString();
       process.stderr.write(data);
+
+      if (!hasAgentRules || earlyKilled || timedOut) return;
+      // Throttle: первый скан всегда, последующие — только после 200+ новых байт.
+      if (lastScanSize > 0 && stderr.length - lastScanSize < 200) return;
+      lastScanSize = stderr.length;
+      const match = scanStderrForFatalRule(rules, agentId, stderr);
+      if (!match) return;
+
+      earlyKilled = true;
+      clearTimeout(timeoutId);
+      if (logger) {
+        logger.error?.(
+          `Fatal stderr pattern matched for ${agentId} (rule=${match.rule_id}, class=${match.class}). Killing process.`,
+          stageId
+        );
+      }
+      killChild();
+      const err = new Error(
+        `Agent "${agentId}" killed early: ${match.rule_id} (class=${match.class})`
+      );
+      err.code = 'EARLY_KILL';
+      err.exitCode = -1;
+      err.stderr = stderr;
+      err.earlyKill = true;
+      err.rule = match;
+      reject(err);
     });
 
     child.on('close', (code) => {
@@ -264,7 +305,7 @@ export async function spawnAgent(agentConfig, prompt, options = {}) {
       }
       process.stdout.write('\n');
 
-      if (timedOut) return;
+      if (timedOut || earlyKilled) return;
 
       if (logger) {
         logger.cliCall(agentConfig.command, args, code);
@@ -324,7 +365,7 @@ export async function spawnAgent(agentConfig, prompt, options = {}) {
 
     child.on('error', (err) => {
       clearTimeout(timeoutId);
-      if (!timedOut) {
+      if (!timedOut && !earlyKilled) {
         if (logger) {
           logger.error(`CLI error: ${err.message}`, stageId);
         }