workflow-ai 1.0.64 → 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/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,95 +1,94 @@
-{
-  "date": "2026-04-19T12:30:16.942Z",
-  "skill_sha": "3c4e051",
-  "status": "passed",
-  "duration_ms": 1,
-  "l1_skipped": true,
-  "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
+    }
+  ]
 }