workflow-ai 1.0.65 → 1.0.66

package/src/runner.mjs

@@ -6,6 +6,9 @@ import { spawn, execSync } from 'child_process';
 import crypto from 'crypto';
 import yaml from './lib/js-yaml.mjs';
 import { findProjectRoot } from './lib/find-root.mjs';
+import { loadRules, scanStderrForFatalRule, classify } from './lib/error-classifier.mjs';
+import { snapshot, diff, isEmpty } from './lib/artifact-snapshot.mjs';
+import { markUnhealthy, isHealthy } from './lib/agent-health-registry.mjs';
 
 // ============================================================================
 // Logger — система логирования с уровнями DEBUG/INFO/WARN/ERROR
@@ -846,6 +849,26 @@ class StageExecutor {
 
     // Текущий дочерний процесс агента (для kill при shutdown)
     this.currentChild = null;
+
+    // Правила health-классификатора (инициализируются один раз в конструкторе)
+    this.rules = loadRules(projectRoot);
+
+    // Лениво загружаемые правила health-классификатора для онлайн-сканирования stderr
+    this._healthRules = null;
+  }
+
+  /** Возвращает правила health-классификатора, загружая их при первом обращении. */
+  _getHealthRules() {
+    if (this._healthRules !== null) return this._healthRules;
+    try {
+      this._healthRules = loadRules(this.projectRoot);
+    } catch (e) {
+      if (this.logger) {
+        this.logger.warn(`Failed to load agent-health-rules: ${e.message}`, 'CLI');
+      }
+      this._healthRules = { common: [], agents: new Map() };
+    }
+    return this._healthRules;
   }
 
   /**
@@ -875,8 +898,13 @@ class StageExecutor {
    *   4. Скрипт-агенты (stage.agent: script-*) обрабатываются в отдельной ветке
    *      execute() — сюда не попадают.
    */
-  resolveAgent(stage, stageId) {
-    const attempt = (stage.counter && this.counters[stage.counter]) || 1;
+  resolveAgent(stage, stageId, options = {}) {
+    const excludeAgents = options.excludeAgents || [];
+    // Семантика: counter = число УЖЕ ИСЧЕРПАННЫХ попыток (0 на старте, инкрементируется
+    // стадией `increment-*-attempts` ПОСЛЕ каждой неудачи). attempt — номер текущей
+    // (1-based). Читаем counter через ?? 0, чтобы отличать «ещё не запускались»
+    // от «была 1 попытка» — иначе оффсет-by-one и ротация застревает на первом агенте.
+    const attempt = (stage.counter ? (this.counters[stage.counter] ?? 0) : 0) + 1;
 
     // Task type: явно из context либо из префикса ticket_id
     const taskType = this.context.task_type
@@ -921,9 +949,28 @@ class StageExecutor {
       const caps = Array.isArray(agent.capabilities) ? agent.capabilities : [];
       return required.every(r => caps.includes(r));
     };
-    const compatible = agentIds.filter(covers);
-
-    if (compatible.length === 0) {
+    const afterCapabilities = agentIds.filter(covers);
+
+    // Фильтр по health-реестру: unhealthy-агенты с неистёкшим TTL пропускаются.
+    // Реестр персистентный между attempt'ами (план rev.3, решение 6.5).
+    const afterHealth = afterCapabilities.filter(id => isHealthy(this.projectRoot, id));
+
+    // Фильтр по excludeAgents (для in-stage fallback в рамках одной attempt)
+    const afterExclude = excludeAgents.length > 0
+      ? afterHealth.filter(id => !excludeAgents.includes(id))
+      : afterHealth;
+
+    if (afterExclude.length === 0) {
+      // Все capability-совместимые агенты либо unhealthy в реестре, либо уже пробованы в этой attempt.
+      if (afterCapabilities.length > 0) {
+        return {
+          blocked: 'all_unhealthy',
+          reason: excludeAgents.length > 0
+            ? `All agents tried in fallback`
+            : `All capable agents are unhealthy in registry`,
+          attempt
+        };
+      }
       return {
         blocked: 'no_capable_agent',
         reason: `No agent in [${agentIds.join(', ')}] covers required_capabilities [${required.join(', ')}]`,
@@ -932,12 +979,111 @@ class StageExecutor {
     }
 
     // Курсор = (attempt - 1) % length — ротация по кругу
-    const cursor = (attempt - 1) % compatible.length;
+    const cursor = (attempt - 1) % afterExclude.length;
 
-    const agentId = compatible[cursor];
+    const agentId = afterExclude[cursor];
     // Клонируем stage с подменой instructions (для agents_by_type override)
     const effectiveStage = { ...stage, instructions };
-    return { agentId, effectiveStage, attempt, compatible };
+    return { agentId, effectiveStage, attempt, compatible: afterExclude };
+  }
+
+  /**
+   * Выполняет stage с fallback-логикой: при пустом artifact diff делает retry с другим агентом.
+   * @param {string} stageId - ID stage из конфигурации
+   * @param {object} [stageOverride] - явный stage (для тестов и промежуточных вызовов); по умолчанию берётся из pipeline.stages
+   * @returns {Promise<{status: string, output: string, result?: object}>}
+   */
+  async executeWithFallback(stageId, stageOverride) {
+    const stage = stageOverride ?? this.pipeline.stages[stageId];
+    if (!stage) {
+      throw new Error(`Stage not found: ${stageId}`);
+    }
+
+    const triedInThisAttempt = [];
+    let lastErr = null;
+
+    const snapshotEnabled = this.pipeline.execution?.artifact_snapshot_enabled !== false;
+    const snapshotOpts = {
+      includePaths: this.pipeline.execution?.snapshot_paths ?? ['src', 'configs'],
+      snapshotMaxFileSize: this.pipeline.execution?.snapshot_max_file_size ?? 524288,
+    };
+
+    while (true) {
+      const resolved = this.resolveAgent(stage, stageId, { excludeAgents: triedInThisAttempt });
+
+      if (resolved.blocked) {
+        // all_unhealthy после исчерпания списка в текущей attempt (lastErr есть) —
+        // re-throw, чтобы стадия ушла в goto.error и inc-counter. Без lastErr —
+        // первая итерация while, агентов сразу нет (persistence из прошлой attempt)
+        // → возвращаем blocked, чтобы конфиг мог развести goto.blocked vs goto.error.
+        if (resolved.blocked === 'all_unhealthy' && lastErr) {
+          throw lastErr;
+        }
+        return { status: 'blocked', blocked_reason: resolved.blocked, reason: resolved.reason };
+      }
+
+      const { agentId, effectiveStage } = resolved;
+      const agent = this.pipeline.agents[agentId];
+      const prompt = this.promptBuilder.build(effectiveStage, stageId);
+
+      const before = snapshotEnabled ? await snapshot(this.projectRoot, snapshotOpts) : null;
+
+      try {
+        if (this.logger) {
+          this.logger.info(
+            `Agent selected: ${agentId} (attempt ${resolved.attempt}, compatible=[${resolved.compatible.join(', ')}])`,
+            stageId
+          );
+          this.logger.stageStart(stageId, agentId, effectiveStage.skill);
+        }
+
+        const result = await this.callAgent(agent, prompt, stageId, effectiveStage.skill, agentId);
+
+        if (this.logger) this.logger.stageComplete(stageId, result.status, result.exitCode);
+        return result;
+      } catch (err) {
+        if (!err.exitCode && !err.code) throw err;
+
+        const exitCode = err.exitCode ?? err.code;
+        const stderr = err.stderr || '';
+
+        const after = snapshotEnabled ? await snapshot(this.projectRoot, snapshotOpts) : null;
+        const diffResult = snapshotEnabled ? diff(before, after) : null;
+        const diffEmpty = snapshotEnabled && isEmpty(diffResult);
+
+        const classification = await classify(this.rules, agentId, { exitCode, stderr });
+        if (classification) {
+          markUnhealthy(this.projectRoot, agentId, classification);
+          if (this.logger) {
+            this.logger.info(
+              `agent ${agentId} marked unhealthy: class=${classification.class}, excluded (fallback triggered)`,
+              stageId
+            );
+          }
+        }
+
+        if (!diffEmpty) {
+          const changedPaths = diffResult ? Object.keys(diffResult).join(', ') : 'unknown';
+          if (this.logger) {
+            this.logger.warn(
+              `agent ${agentId} exited ${exitCode}, artifacts modified [${changedPaths}] — fallback blocked`,
+              stageId
+            );
+          }
+          throw err;
+        }
+
+        if (this.logger) {
+          this.logger.info(
+            `agent ${agentId} exited ${exitCode}, artifact diff empty — falling back in-stage (class=${classification?.class ?? 'unmatched'})`,
+            stageId
+          );
+        }
+
+        triedInThisAttempt.push(agentId);
+        lastErr = err;
+      }
+    }
   }
 
   /**
@@ -961,7 +1107,7 @@ class StageExecutor {
       const skipGuard = this.fileGuard && this.fileGuard.isTrusted(stage.agent, stageId);
       if (this.fileGuard && !skipGuard) this.fileGuard.takeSnapshot();
 
-      const result = await this.callAgent(agent, prompt, stageId, stage.skill);
+      const result = await this.callAgent(agent, prompt, stageId, stage.skill, stage.agent);
 
       if (this.logger) this.logger.stageComplete(stageId, result.status, result.exitCode);
       if (this.fileGuard && !skipGuard) {
@@ -971,56 +1117,20 @@ class StageExecutor {
       return result;
     }
 
-    // Новая ветка: список кандидатов с фильтром по capabilities
-    const resolved = this.resolveAgent(stage, stageId);
-    if (resolved.blocked) {
-      if (this.logger) {
-        this.logger.error(
-          `Stage "${stageId}" blocked: ${resolved.blocked} — ${resolved.reason}`,
-          stageId
-        );
-      }
-      return {
-        status: 'blocked',
-        blocked_reason: resolved.blocked,
-        output: resolved.reason,
-        result: { blocked: resolved.blocked, reason: resolved.reason },
-        exitCode: 0,
-        parsed: false
-      };
-    }
-
-    const { agentId, effectiveStage } = resolved;
-    const agent = this.pipeline.agents[agentId];
-    const prompt = this.promptBuilder.build(effectiveStage, stageId);
-
-    if (this.logger) {
-      this.logger.info(
-        `Agent selected: ${agentId} (attempt ${resolved.attempt}, compatible=[${resolved.compatible.join(', ')}])`,
-        stageId
-      );
-      this.logger.stageStart(stageId, agentId, effectiveStage.skill);
-    }
-
-    const skipGuard = this.fileGuard && this.fileGuard.isTrusted(agentId, stageId);
-    if (this.fileGuard && !skipGuard) this.fileGuard.takeSnapshot();
-
-    const result = await this.callAgent(agent, prompt, stageId, effectiveStage.skill);
-
-    if (this.logger) this.logger.stageComplete(stageId, result.status, result.exitCode);
-    if (this.fileGuard && !skipGuard) {
-      const violations = this.fileGuard.checkAndRollback();
-      if (violations.length > 0) result.violations = violations;
-    }
-    return result;
+    // Новая ветка: список кандидатов с фильтром по capabilities → executeWithFallback
+    return this.executeWithFallback(stageId);
   }
 
   /**
    * Вызывает CLI-агента через child_process
    */
-  callAgent(agent, prompt, stageId, skillId) {
+  callAgent(agent, prompt, stageId, skillId, agentId = null) {
     return new Promise((resolve, reject) => {
       const timeout = this.pipeline.execution?.timeout_per_stage || 300;
+      const healthRules = agentId ? this._getHealthRules() : null;
+      const hasAgentRules = Boolean(
+        healthRules && agentId && healthRules.agents.get(agentId)?.length
+      );
       const args = [...agent.args];
       const finalPrompt = prompt;
 
@@ -1065,16 +1175,23 @@ class StageExecutor {
       let stdout = '';
       let stderr = '';
       let timedOut = false;
+      let earlyKilled = false;
+      let earlyKillRule = null;
+      let lastScanSize = 0;
 
-      // Таймаут
-      const timeoutId = setTimeout(() => {
-        timedOut = true;
-        // На Windows SIGTERM игнорируется — используем taskkill /T /F для убийства дерева
+      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;
+        // На Windows SIGTERM игнорируется — используем taskkill /T /F для убийства дерева
+        killChild();
         if (this.logger) {
           this.logger.timeout(stageId, timeout);
         }
@@ -1120,6 +1237,36 @@ class StageExecutor {
       child.stderr.on('data', (data) => {
         stderr += data.toString();
         process.stderr.write(data);
+
+        // Online-детекция фатальных паттернов (quota/429/usage-limit и т.п.).
+        // Нужна чтобы не ждать timeout_per_stage (1800s), когда агентский CLI
+        // уходит в молчаливый retry-цикл после HTTP 429.
+        if (!hasAgentRules || earlyKilled || timedOut) return;
+        // Throttle: первый скан всегда, последующие — только после 200+ новых байт.
+        if (lastScanSize > 0 && stderr.length - lastScanSize < 200) return;
+        lastScanSize = stderr.length;
+        const match = scanStderrForFatalRule(healthRules, agentId, stderr);
+        if (!match) return;
+
+        earlyKilled = true;
+        earlyKillRule = match;
+        clearTimeout(timeoutId);
+        if (this.logger) {
+          this.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) => {
@@ -1139,6 +1286,16 @@ class StageExecutor {
         process.stdout.write('\n');
 
         if (timedOut) return;
+        if (earlyKilled) {
+          if (this.logger && stderr.trim()) {
+            this.logger.warn(`STDERR ↓`, stageId);
+            for (const line of stderr.trim().split('\n')) {
+              this.logger.warn(`  ${line}`, stageId);
+            }
+            this.logger.warn(`STDERR ↑`, stageId);
+          }
+          return;
+        }
 
         // Логгируем CLI вызов
         if (this.logger) {
@@ -1205,7 +1362,7 @@ class StageExecutor {
 
       child.on('error', (err) => {
         clearTimeout(timeoutId);
-        if (!timedOut) {
+        if (!timedOut && !earlyKilled) {
           if (this.logger) {
             this.logger.error(`CLI error: ${err.message}`, stageId);
           }

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

@@ -1,94 +1,94 @@
-{
-  "date": "2026-04-21T08:57:32.459Z",
-  "skill_sha": "6df42d0",
-  "status": "passed",
-  "duration_ms": 1,
-  "per_model": {
-    "claude-sonnet": {
-      "passed": true,
-      "pass_count": 3,
-      "total": 3,
-      "threshold": 2
-    },
-    "kilo-deepseek": {
-      "passed": true,
-      "pass_count": 2,
-      "total": 3,
-      "threshold": 2
-    },
-    "kilo-minimax": {
-      "passed": true,
-      "pass_count": 2,
-      "total": 3,
-      "threshold": 2
-    },
-    "kilo-glm": {
-      "passed": true,
-      "pass_count": 3,
-      "total": 3,
-      "threshold": 2
-    }
-  },
-  "rubric_scores": [
-    {
-      "agentId": "claude-sonnet",
-      "trial": 1,
-      "score": 5
-    },
-    {
-      "agentId": "claude-sonnet",
-      "trial": 2,
-      "score": 5
-    },
-    {
-      "agentId": "claude-sonnet",
-      "trial": 3,
-      "score": 5
-    },
-    {
-      "agentId": "kilo-deepseek",
-      "trial": 1,
-      "score": 5
-    },
-    {
-      "agentId": "kilo-deepseek",
-      "trial": 2,
-      "score": 1
-    },
-    {
-      "agentId": "kilo-deepseek",
-      "trial": 3,
-      "score": 5
-    },
-    {
-      "agentId": "kilo-glm",
-      "trial": 1,
-      "score": 5
-    },
-    {
-      "agentId": "kilo-glm",
-      "trial": 2,
-      "score": 5
-    },
-    {
-      "agentId": "kilo-glm",
-      "trial": 3,
-      "score": 5
-    },
-    {
-      "agentId": "kilo-minimax",
-      "trial": 1,
-      "score": 3
-    },
-    {
-      "agentId": "kilo-minimax",
-      "trial": 2,
-      "score": 5
-    },
-    {
-      "agentId": "kilo-minimax",
-      "trial": 3,
-      "score": 5
-    }
-  ]
+{
+  "date": "2026-04-21T16:43:17.710Z",
+  "skill_sha": "6df42d0",
+  "status": "passed",
+  "duration_ms": 2,
+  "per_model": {
+    "claude-sonnet": {
+      "passed": true,
+      "pass_count": 3,
+      "total": 3,
+      "threshold": 2
+    },
+    "kilo-deepseek": {
+      "passed": true,
+      "pass_count": 2,
+      "total": 3,
+      "threshold": 2
+    },
+    "kilo-minimax": {
+      "passed": true,
+      "pass_count": 2,
+      "total": 3,
+      "threshold": 2
+    },
+    "kilo-glm": {
+      "passed": true,
+      "pass_count": 3,
+      "total": 3,
+      "threshold": 2
+    }
+  },
+  "rubric_scores": [
+    {
+      "agentId": "claude-sonnet",
+      "trial": 1,
+      "score": 5
+    },
+    {
+      "agentId": "claude-sonnet",
+      "trial": 2,
+      "score": 5
+    },
+    {
+      "agentId": "claude-sonnet",
+      "trial": 3,
+      "score": 5
+    },
+    {
+      "agentId": "kilo-deepseek",
+      "trial": 1,
+      "score": 5
+    },
+    {
+      "agentId": "kilo-deepseek",
+      "trial": 2,
+      "score": 1
+    },
+    {
+      "agentId": "kilo-deepseek",
+      "trial": 3,
+      "score": 5
+    },
+    {
+      "agentId": "kilo-glm",
+      "trial": 1,
+      "score": 5
+    },
+    {
+      "agentId": "kilo-glm",
+      "trial": 2,
+      "score": 5
+    },
+    {
+      "agentId": "kilo-glm",
+      "trial": 3,
+      "score": 5
+    },
+    {
+      "agentId": "kilo-minimax",
+      "trial": 1,
+      "score": 3
+    },
+    {
+      "agentId": "kilo-minimax",
+      "trial": 2,
+      "score": 5
+    },
+    {
+      "agentId": "kilo-minimax",
+      "trial": 3,
+      "score": 5
+    }
+  ]
 }