@fede0089/skill-eval 1.3.0 → 1.4.1

package/README.md

@@ -6,11 +6,11 @@ A CLI tool for evaluating Agent Skills locally. Tests whether your skill trigger
 
 Skills are instructions that change how the agent behaves. But a single successful run isn't enough to trust one — agents are non-deterministic, and a good isolated result can be exactly that: an isolated case.
 
-Skill evals let you turn that intuition into evidence: run several comparable tasks with and without the skill, measure them against the same criteria, and validate whether the agent improves consistently against a baseline.
+Skill evals let you turn that intuition into evidence: run several comparable tasks with the skill, measure them against the same criteria, and optionally compare against a baseline or historical skill branches.
 
 ## How it works
 
-For each eval prompt, skill-eval spins up parallel agent processes — some with the skill installed, others without (the baseline). Each agent runs headlessly and produces a transcript. An LLM judge then grades each transcript against your expectations. Results are aggregated into **pass@k** metrics, giving you a clear measure of how much your skill actually improves the agent's behavior versus the unassisted baseline.
+For each eval prompt, skill-eval spins up parallel agent processes with the current skill installed by default. You can optionally add the no-skill baseline or historical skill branches for side-by-side comparison. Each agent runs headlessly and produces a transcript. An LLM judge then grades each transcript against your expectations. Results are aggregated into **pass@k** metrics, giving you a clear view of how the skill behaves in isolation or relative to comparison targets.
 
 ```
                   eval prompt
@@ -20,7 +20,7 @@ For each eval prompt, skill-eval spins up parallel agent processes — some with
                └───────┬───────┘
                        │
            ┌───────────┴───────────┐
-      ─ with skill ─          ─ baseline ─
+      ─ with skill ─        ─ baseline (opt) ─
       ┌──────┴──────┐         ┌─────┴──────┐
     agent 1      agent 2   agent 3      agent 4
       │              │         │             │
@@ -32,6 +32,8 @@ For each eval prompt, skill-eval spins up parallel agent processes — some with
 ```
 
 > The `trigger` command only runs with-skill trials and checks whether the skill dispatch tool was actually invoked — no judge or baseline needed.
+>
+> The baseline branch is opt-in: enable it with `--compare-baseline` (no-skill control) or `--compare-ref <ref>` (historical skill versions).
 
 ## Installation
 
@@ -66,7 +68,7 @@ npm link        # makes `skill-eval` available globally
 # Checks that the skill is triggered (invoked) for each prompt
 skill-eval trigger --workspace <path> --skill <path> [options] [agent]
 
-# Checks that the skill produces correct output, measured against a baseline
+# Checks that the skill produces correct output (skill-only by default)
 skill-eval functional --workspace <path> --skill <path> [options] [agent]
 ```
 
@@ -81,6 +83,7 @@ skill-eval functional --workspace <path> --skill <path> [options] [agent]
 | `--timeout <seconds>` | no | none | Kill the agent after this many seconds |
 | `--eval-id <id>` | no | all | Run only the eval with this numeric ID |
 | `--compare-ref [refs...]` | no | — | Git references to compare against |
+| `--compare-baseline` | no | `false` | Also run the no-skill baseline alongside the skill |
 | `-v, --debug` | no | `false` | Enable verbose debug logging |
 | `[agent]` | no | `gemini-cli` | Agent backend to use |
 
@@ -156,6 +159,7 @@ Refer to your runner's documentation for the full list of available settings and
 This repo includes a `mock-skill/` directory — a complete, working example of a license-generator skill with trigger and functional evals. Run it directly with:
 
 ```sh
+npm run test:unit        # run the unit test suite
 npm run test:trigger     # trigger evaluation against mock-skill
 npm run test:functional  # functional evaluation against mock-skill
 ```
@@ -180,17 +184,4 @@ The factory, preflight check, and CLI all pick it up automatically.
 ### Adding a new report format
 
 1. Create `src/reporters/<format>-reporter.ts` implementing `Reporter`.
-2. Export it and add a case in `createReporter()` in `src/reporters/index.ts`.
-3. Add the format string to `ReportFormat` in `src/types/index.ts`.
-er, binary: '<cli-binary-name>' },
-   ```
-
-The factory, preflight check, and CLI all pick it up automatically.
-
-> Implement `applyRunnerConfig(evalConfigBaseDir, worktreePath)` to copy `evalConfigBaseDir/<your-agent>/` into the appropriate config directory in the worktree (e.g. `.claude/` for a Claude runner). No-op silently if the directory doesn't exist.
-
-### Adding a new report format
-
-1. Create `src/reporters/<format>-reporter.ts` implementing `Reporter`.
-2. Export it and add a case in `createReporter()` in `src/reporters/index.ts`.
-3. Add the format string to `ReportFormat` in `src/types/index.ts`.
+2. Add a case for it in `createReporter()` in `src/reporters/index.ts`.

package/dist/commands/functional.js

@@ -13,7 +13,7 @@ import { renderFunctionalTable, renderRunHeader } from '../utils/table-renderer.
 import { JsonReporter } from '../reporters/index.js';
 import chalk from 'chalk';
 import { git } from '../utils/git.js';
-export async function functionalCommand(agent, workspace, skillPath, maxAgents = 4, injectedSuite, numTrials = 3, reporter = new JsonReporter(), timeoutMs, evalId, compareRefs = []) {
+export async function functionalCommand(agent, workspace, skillPath, maxAgents = 4, injectedSuite, numTrials = 3, reporter = new JsonReporter(), timeoutMs, evalId, compareRefs = [], compareBaseline = false) {
     if (!injectedSuite)
         preflight(agent, workspace, skillPath);
     const suite = injectedSuite || evalLoader.loadEvalSuite(skillPath);
@@ -63,10 +63,10 @@ export async function functionalCommand(agent, workspace, skillPath, maxAgents =
         }));
     }
     // 3. Baseline Runner
-    const withoutSkillRunner = new EvalRunner({
+    const withoutSkillRunner = compareBaseline ? new EvalRunner({
         agent, workspace, skillPath, skillName: skill_name, runDir, isBaseline: true, debug, timeoutMs,
         variant: 'baseline'
-    });
+    }) : undefined;
     const taskResults = [];
     let withSkillTasksAllPassedCount = 0;
     let baselineTasksAllPassedCount = 0;
@@ -76,10 +76,12 @@ export async function functionalCommand(agent, workspace, skillPath, maxAgents =
     let barrier = Promise.resolve();
     // Subtask labels
     const skillVersions = Array.from(variantRunners.keys());
-    const subtaskLabels = [
-        ...Array.from({ length: numTrials }, (_, i) => `Without Skill ${i + 1}`),
-        ...skillVersions.flatMap(v => Array.from({ length: numTrials }, (_, i) => `${v} ${i + 1}`))
-    ];
+    const subtaskLabels = compareBaseline
+        ? [
+            ...Array.from({ length: numTrials }, (_, i) => `Without Skill ${i + 1}`),
+            ...skillVersions.flatMap(v => Array.from({ length: numTrials }, (_, i) => `${v} ${i + 1}`))
+        ]
+        : skillVersions.flatMap(v => Array.from({ length: numTrials }, (_, i) => `${v} ${i + 1}`));
     try {
         renderRunHeader({ command: 'functional', skillName: skill_name, agent, workspace, tasks: tasks.length, trials: numTrials, maxAgents, timeoutMs, runDir, evalId });
         Logger.write(`──────────────────────────────────────────────────\n`);
@@ -98,34 +100,36 @@ export async function functionalCommand(agent, workspace, skillPath, maxAgents =
                     await thisBarrier;
                     // 1. Without Skill trials
                     const baselineTrialPromises = [];
-                    for (let idx = 0; idx < numTrials; idx++) {
-                        const trialId = idx + 1;
-                        const trialCtx = multi?.getTrialCtx(trialId) ?? uiCtx;
-                        const release = await pool.acquire();
-                        const p = withRetry((attempt) => withoutSkillRunner.runFunctionalTask(task, i, trialId, trialCtx, attempt)
-                            .catch((error) => ({
-                            id: trialId,
-                            transcript: { error: error instanceof Error ? error.message : String(error) },
-                            assertionResults: [{ assertion: 'Without Skill Execution', passed: false, reason: String(error) }],
-                            trialPassed: false,
-                            isError: true
-                        })), 2, 1000, (nextAttempt, lastTrial) => {
-                            const reason = lastTrial.assertionResults[0]?.reason ?? 'infrastructure error';
-                            trialCtx.updateLog(`Retry ${nextAttempt}/2 — ${reason.substring(0, 50)}`);
-                        }).then(trial => {
-                            if (multi) {
-                                const reason = trial.assertionResults.find(r => !r.passed)?.reason;
-                                const passedCount = trial.assertionResults.filter(r => r.passed).length;
-                                const totalCount = trial.assertionResults.length;
-                                multi.markTrialComplete(trialId, trial.trialPassed, reason, trial.isError, passedCount, totalCount);
-                            }
-                            return trial;
-                        }).finally(release);
-                        baselineTrialPromises.push(p);
+                    if (withoutSkillRunner) {
+                        for (let idx = 0; idx < numTrials; idx++) {
+                            const trialId = idx + 1;
+                            const trialCtx = multi?.getTrialCtx(trialId) ?? uiCtx;
+                            const release = await pool.acquire();
+                            const p = withRetry((attempt) => withoutSkillRunner.runFunctionalTask(task, i, trialId, trialCtx, attempt)
+                                .catch((error) => ({
+                                id: trialId,
+                                transcript: { error: error instanceof Error ? error.message : String(error) },
+                                assertionResults: [{ assertion: 'Without Skill Execution', passed: false, reason: String(error) }],
+                                trialPassed: false,
+                                isError: true
+                            })), 2, 1000, (nextAttempt, lastTrial) => {
+                                const reason = lastTrial.assertionResults[0]?.reason ?? 'infrastructure error';
+                                trialCtx.updateLog(`Retry ${nextAttempt}/2 — ${reason.substring(0, 50)}`);
+                            }).then(trial => {
+                                if (multi) {
+                                    const reason = trial.assertionResults.find(r => !r.passed)?.reason;
+                                    const passedCount = trial.assertionResults.filter(r => r.passed).length;
+                                    const totalCount = trial.assertionResults.length;
+                                    multi.markTrialComplete(trialId, trial.trialPassed, reason, trial.isError, passedCount, totalCount);
+                                }
+                                return trial;
+                            }).finally(release);
+                            baselineTrialPromises.push(p);
+                        }
                     }
                     // 2. Skill variants trials
                     const variantTrialsPromises = {};
-                    let currentSubtaskIdx = numTrials;
+                    let currentSubtaskIdx = compareBaseline ? numTrials : 0;
                     for (const [version, runner] of variantRunners.entries()) {
                         variantTrialsPromises[version] = [];
                         for (let idx = 0; idx < numTrials; idx++) {
@@ -158,19 +162,17 @@ export async function functionalCommand(agent, workspace, skillPath, maxAgents =
                     }
                     // All slots for this prompt have been acquired — signal the next prompt.
                     resolveBarrier();
-                    const [woTrials, ...versionsTrials] = await Promise.all([
-                        Promise.all(baselineTrialPromises),
-                        ...Object.values(variantTrialsPromises).map(ps => Promise.all(ps))
-                    ]);
+                    const variantsTrials = await Promise.all(Object.values(variantTrialsPromises).map(ps => Promise.all(ps)));
+                    const woTrials = withoutSkillRunner ? await Promise.all(baselineTrialPromises) : [];
                     const woPassedCount = woTrials.filter(t => t.trialPassed).length;
-                    if (woPassedCount === woTrials.length)
+                    if (withoutSkillRunner && woPassedCount === woTrials.length)
                         baselineTasksAllPassedCount++;
                     const taskSkillTrials = {};
                     const variantNames = Object.keys(variantTrialsPromises);
                     let localAllPassed = true;
                     for (let vIdx = 0; vIdx < variantNames.length; vIdx++) {
                         const vName = variantNames[vIdx];
-                        const vTrials = versionsTrials[vIdx];
+                        const vTrials = variantsTrials[vIdx];
                         taskSkillTrials[vName] = vTrials.map(t => ({ ...t, transcript: undefined }));
                         if (vName === 'local') {
                             const passedCount = vTrials.filter(t => t.trialPassed).length;
@@ -185,7 +187,7 @@ export async function functionalCommand(agent, workspace, skillPath, maxAgents =
                     const taskResult = {
                         taskId: task.id,
                         prompt: task.prompt,
-                        baselineTrials: woTrials.map(t => ({ ...t, transcript: undefined })),
+                        baselineTrials: withoutSkillRunner ? woTrials.map(t => ({ ...t, transcript: undefined })) : [],
                         skillTrials: taskSkillTrials
                     };
                     taskResults.push(taskResult);
@@ -199,25 +201,28 @@ export async function functionalCommand(agent, workspace, skillPath, maxAgents =
         await ui.run(tasks.length);
         // ==== REPORTING ====
         const allSkillVersions = taskResults.length > 0 ? Object.keys(taskResults[0].skillTrials) : ['local'];
-        const allVersions = ['baseline', ...allSkillVersions];
+        const hasBaseline = compareBaseline;
+        const allVersions = hasBaseline ? ['baseline', ...allSkillVersions] : allSkillVersions;
         const scores = {};
         const passAtK = {};
         const assertionPassRate = {};
         const tokenStats = {};
         const durationStats = {};
         // 1. Baseline Metrics
-        const { passAtK: woPassAtK } = aggregatePassAtK(taskResults, numTrials, r => r.baselineTrials);
-        const woAssertionPassRate = aggregateAssertionPassRate(taskResults, r => r.baselineTrials);
-        const woPercentage = Math.round(woAssertionPassRate * 100);
-        scores['baseline'] = `${woPercentage}%`;
-        passAtK['baseline'] = Math.round(woPassAtK * 1000) / 1000;
-        assertionPassRate['baseline'] = Math.round(woAssertionPassRate * 1000) / 1000;
-        const woTokens = aggregateTokenStats(taskResults.flatMap(r => r.baselineTrials));
-        if (woTokens)
-            tokenStats['baseline'] = woTokens;
-        const woDuration = aggregateDurationStats(taskResults.flatMap(r => r.baselineTrials));
-        if (woDuration)
-            durationStats['baseline'] = woDuration;
+        if (hasBaseline) {
+            const { passAtK: woPassAtK } = aggregatePassAtK(taskResults, numTrials, r => r.baselineTrials);
+            const woAssertionPassRate = aggregateAssertionPassRate(taskResults, r => r.baselineTrials);
+            const woPercentage = Math.round(woAssertionPassRate * 100);
+            scores['baseline'] = `${woPercentage}%`;
+            passAtK['baseline'] = Math.round(woPassAtK * 1000) / 1000;
+            assertionPassRate['baseline'] = Math.round(woAssertionPassRate * 1000) / 1000;
+            const woTokens = aggregateTokenStats(taskResults.flatMap(r => r.baselineTrials));
+            if (woTokens)
+                tokenStats['baseline'] = woTokens;
+            const woDuration = aggregateDurationStats(taskResults.flatMap(r => r.baselineTrials));
+            if (woDuration)
+                durationStats['baseline'] = woDuration;
+        }
         // 2. Skill Variants Metrics
         for (const version of allSkillVersions) {
             const { passAtK: wiPassAtK } = aggregatePassAtK(taskResults, numTrials, r => r.skillTrials[version] || []);
@@ -235,6 +240,7 @@ export async function functionalCommand(agent, workspace, skillPath, maxAgents =
         }
         const report = {
             timestamp: startTime.toISOString(),
+            command: 'functional',
             skill_name,
             agent,
             metrics: {

package/dist/commands/trigger.js

@@ -183,6 +183,7 @@ export async function triggerCommand(agent, workspace, skillPath, maxAgents = 4,
         }
         const report = {
             timestamp: startTime.toISOString(),
+            command: 'trigger',
             skill_name,
             agent,
             metrics: {

package/dist/index.js

@@ -8,7 +8,9 @@ import { HtmlReporter } from './reporters/index.js';
 import { DEFAULT_AGENT } from './runners/registry.js';
 import * as path from 'path';
 import * as fs from 'fs';
+import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
+const pkg = createRequire(import.meta.url)('../package.json');
 export const program = new Command();
 const errorHandler = (err) => {
     if (err instanceof AppError) {
@@ -26,7 +28,7 @@ const errorHandler = (err) => {
 program
     .name('skill-eval')
     .description('CLI to evaluate agent skills triggering and functionality')
-    .version('1.0.0')
+    .version(pkg.version)
     .option('-v, --debug', 'Enable debug logging', false);
 program.on('option:debug', () => {
     process.env.DEBUG = 'true';
@@ -36,16 +38,16 @@ program
     .description('Evaluate triggering of an agent skill')
     .requiredOption('--workspace <path>', 'Path to the workspace/repo to evaluate against')
     .requiredOption('--skill <path>', 'Path to the skill directory')
-    .option('--agents <number>', 'Number of parallel agents')
-    .option('--trials <number>', 'Number of trials per task for pass@k calculation')
+    .option('--agents <number>', 'Number of parallel agents', '4')
+    .option('--trials <number>', 'Number of trials per task for pass@k calculation', '3')
     .option('--timeout <seconds>', 'Agent timeout in seconds')
     .option('--eval-id <id>', 'Run only the eval with this ID (numeric)')
     .option('--compare-ref [refs...]', 'Compare against historical git references')
     .action((agent, options) => {
     const workspace = path.resolve(options.workspace);
     const selectedAgent = agent || DEFAULT_AGENT;
-    const maxAgents = parseInt(options.agents, 10) || 4;
-    const numTrials = options.trials !== undefined ? (parseInt(options.trials, 10) || 3) : 3;
+    const maxAgents = parseInt(options.agents, 10);
+    const numTrials = parseInt(options.trials, 10);
     const timeoutMs = options.timeout ? parseInt(options.timeout, 10) * 1000 : undefined;
     const evalId = options.evalId !== undefined ? parseInt(options.evalId, 10) : undefined;
     const compareRefs = options.compareRef || [];
@@ -53,23 +55,25 @@ program
 });
 program
     .command('functional [agent]')
-    .description('Evaluate functional correctness of an agent skill based on assertions')
+    .description('Evaluate functional correctness of an agent skill against expectations')
     .requiredOption('--workspace <path>', 'Path to the workspace/repo to evaluate against')
     .requiredOption('--skill <path>', 'Path to the skill directory')
-    .option('--agents <number>', 'Number of parallel agents')
-    .option('--trials <number>', 'Number of trials per task for pass@k calculation')
+    .option('--agents <number>', 'Number of parallel agents', '4')
+    .option('--trials <number>', 'Number of trials per task for pass@k calculation', '3')
     .option('--timeout <seconds>', 'Agent timeout in seconds')
     .option('--eval-id <id>', 'Run only the eval with this ID (numeric)')
     .option('--compare-ref [refs...]', 'Compare against historical git references')
+    .option('--compare-baseline', 'Also run the no-skill baseline alongside the skill')
     .action((agent, options) => {
     const workspace = path.resolve(options.workspace);
     const selectedAgent = agent || DEFAULT_AGENT;
-    const maxAgents = parseInt(options.agents, 10) || 4;
-    const numTrials = options.trials !== undefined ? (parseInt(options.trials, 10) || 3) : 3;
+    const maxAgents = parseInt(options.agents, 10);
+    const numTrials = parseInt(options.trials, 10);
     const timeoutMs = options.timeout ? parseInt(options.timeout, 10) * 1000 : undefined;
     const evalId = options.evalId !== undefined ? parseInt(options.evalId, 10) : undefined;
     const compareRefs = options.compareRef || [];
-    functionalCommand(selectedAgent, workspace, options.skill, maxAgents, undefined, numTrials, new HtmlReporter(), timeoutMs, evalId, compareRefs).catch(errorHandler);
+    const compareBaseline = !!options.compareBaseline;
+    functionalCommand(selectedAgent, workspace, options.skill, maxAgents, undefined, numTrials, new HtmlReporter(), timeoutMs, evalId, compareRefs, compareBaseline).catch(errorHandler);
 });
 const isMain = process.argv[1] && (() => {
     try {

package/dist/reporters/html-reporter.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { Logger } from '../utils/logger.js';
-import { formatTokens, formatDuration } from '../utils/table-renderer.js';
+import { formatTokens, formatDuration, hasFunctionalBaseline } from '../utils/table-renderer.js';
 import { computeAssertionPassRate } from '../core/statistics.js';
 export class HtmlReporter {
     generate(report, runDir) {
@@ -32,7 +32,7 @@ function passColorClass(val) {
     return 'red';
 }
 function isFunctional(report) {
-    return report.metrics.assertionPassRate['baseline'] !== undefined;
+    return report.command === 'functional' || hasFunctionalBaseline(report);
 }
 // ---------------------------------------------------------------------------
 // Metrics Grid
@@ -50,7 +50,7 @@ function renderMetricsGrid(report) {
     const { metrics, results } = report;
     const functional = isFunctional(report);
     const skillVersions = results.length > 0 ? Object.keys(results[0].skillTrials) : ['local'];
-    const allVersions = functional ? ['baseline', ...skillVersions] : skillVersions;
+    const allVersions = functional && hasFunctionalBaseline(report) ? ['baseline', ...skillVersions] : skillVersions;
     const headerCells = allVersions.map(v => `<th>${v}</th>`).join('');
     const successRows = `<tr>
     <td>Success Rate</td>
@@ -112,7 +112,9 @@ function renderExpectationCell(trials, expIdx, variant, taskId, clickable, total
     const detail = `<tr class="exp-detail-row" id="${escapeHtml(detailId)}"><td colspan="${totalCols}"><div class="exp-detail-inner"><div class="exp-detail-header">Judge per trial · <span class="variant-pill">${escapeHtml(variant)}</span></div>${lines}</div></td></tr>`;
     return { cell, detail };
 }
-function renderExpectationsTable(result, allVersions, isFunctionalEval) {
+function renderExpectationsTable(result, isFunctionalEval) {
+    const skillVersions = Object.keys(result.skillTrials);
+    const allVersions = isFunctionalEval && (result.baselineTrials?.length ?? 0) > 0 ? ['baseline', ...skillVersions] : skillVersions;
     let canonical = [];
     for (const v of allVersions) {
         const trials = v === 'baseline' ? result.baselineTrials : result.skillTrials[v];
@@ -159,7 +161,7 @@ function avgTrialDuration(trials) {
 }
 function renderTaskMiniGrid(result, isFunctionalEval) {
     const skillVersions = Object.keys(result.skillTrials);
-    const allVersions = isFunctionalEval ? ['baseline', ...skillVersions] : skillVersions;
+    const allVersions = isFunctionalEval && (result.baselineTrials?.length ?? 0) > 0 ? ['baseline', ...skillVersions] : skillVersions;
     const headerCells = allVersions.map(v => `<th>${v}</th>`).join('');
     const successRows = `<tr>
     <td>Success Rate</td>
@@ -199,11 +201,9 @@ function renderTaskMiniGrid(result, isFunctionalEval) {
 </div>`;
 }
 function renderTaskDetails(result, isFunctionalEval) {
-    const skillVersions = Object.keys(result.skillTrials);
-    const allVersions = isFunctionalEval ? ['baseline', ...skillVersions] : skillVersions;
     const sections = [];
     sections.push(renderTaskMiniGrid(result, isFunctionalEval));
-    sections.push(renderExpectationsTable(result, allVersions, isFunctionalEval));
+    sections.push(renderExpectationsTable(result, isFunctionalEval));
     return `<div class="task-details" id="details-${result.taskId}">${sections.join('')}</div>`;
 }
 // ---------------------------------------------------------------------------

package/dist/utils/table-renderer.js

@@ -51,6 +51,12 @@ export function formatTokens(n) {
         return `${Math.round(n / 1_000)}K`;
     return `${n}`;
 }
+export function hasFunctionalBaseline(report) {
+    if (report.results.some(result => (result.baselineTrials?.length ?? 0) > 0)) {
+        return true;
+    }
+    return report.metrics.passAtK['baseline'] !== undefined || report.metrics.assertionPassRate['baseline'] !== undefined;
+}
 function formatTokenStatsLine(stats) {
     const total = formatTokens(stats.avgTotal);
     const input = formatTokens(stats.avgInput);
@@ -189,7 +195,8 @@ export function renderFunctionalTable(report) {
     const { results, metrics } = report;
     // Identify all versions present (baseline + skill versions)
     const skillVersions = results.length > 0 ? Object.keys(results[0].skillTrials) : ['local'];
-    const allVersions = ['baseline', ...skillVersions];
+    const hasBaseline = hasFunctionalBaseline(report);
+    const allVersions = hasBaseline ? ['baseline', ...skillVersions] : skillVersions;
     const header = ['ID', 'Prompt'];
     for (const version of allVersions) {
         header.push(version);
@@ -201,9 +208,11 @@ export function renderFunctionalTable(report) {
         const row = [result.taskId.toString(), promptSnippet];
         // Baseline
         const woTrials = result.baselineTrials || [];
-        if (woTrials.some(t => t.isError) && !woTrials.every(t => t.isError))
-            hasPartialErrors = true;
-        row.push(formatAssertionRate(woTrials));
+        if (hasBaseline) {
+            if (woTrials.some(t => t.isError) && !woTrials.every(t => t.isError))
+                hasPartialErrors = true;
+            row.push(formatAssertionRate(woTrials));
+        }
         // Skills
         for (const version of skillVersions) {
             const wiTrials = result.skillTrials[version] || [];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fede0089/skill-eval",
-  "version": "1.3.0",
-  "description": "CLI to evaluate agent skills triggering",
+  "version": "1.4.1",
+  "description": "CLI to evaluate agent skills triggering and functionality",
   "main": "dist/index.js",
   "bin": {
     "skill-eval": "dist/index.js"