@fede0089/skill-eval 1.2.2 → 1.4.0

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
@@ -66,7 +66,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 +81,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 |
 

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

@@ -61,6 +61,7 @@ program
     .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;
@@ -69,7 +70,8 @@ program
     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>
@@ -87,38 +87,64 @@ function renderMetricsGrid(report) {
 </div>`;
 }
 // ---------------------------------------------------------------------------
-// Trial details
+// Expectations × Variants table (per-task drill-down)
 // ---------------------------------------------------------------------------
-function renderAssertions(assertions) {
-    if (assertions.length === 0)
-        return '<p class="muted">No assertions recorded.</p>';
-    return assertions.map(a => {
-        const icon = a.passed ? '✓' : '✗';
-        const cls = a.passed ? 'assert-pass' : 'assert-fail';
-        return `<div class="assertion ${cls}">
-  <span class="assert-icon">${icon}</span>
-  <div class="assert-body">
-    <div class="assert-text">${escapeHtml(a.assertion)}</div>
-    ${a.reason ? `<div class="assert-reason">${escapeHtml(a.reason)}</div>` : ''}
-  </div>
-</div>`;
+function renderExpectationCell(trials, expIdx, variant, taskId, clickable, totalCols) {
+    const passed = trials.filter(t => t.assertionResults[expIdx]?.passed).length;
+    const total = trials.length;
+    const rate = total > 0 ? passed / total : 0;
+    const colorCls = passColorClass(rate);
+    const ratePct = formatPercent(rate);
+    const frac = `${passed} / ${total}`;
+    const detailId = `exp-detail-${taskId}-${expIdx}-${variant}`;
+    const dataAttr = clickable ? ` data-detail="${escapeHtml(detailId)}"` : '';
+    const cell = `<td class="pass-cell ${colorCls}"${dataAttr}><span class="rate">${ratePct}</span><span class="frac">${frac}</span></td>`;
+    if (!clickable)
+        return { cell, detail: '' };
+    const lines = trials.map(t => {
+        const r = t.assertionResults[expIdx];
+        const ok = !!r?.passed;
+        const reason = r?.reason ?? '';
+        const icon = ok ? '✓' : '✗';
+        const iconCls = ok ? 'pass' : 'fail';
+        return `<div class="exp-trial-line"><div class="exp-trial-icon ${iconCls}">${icon}</div><div class="exp-trial-body"><span class="trial-label">Trial ${t.id}</span><span class="trial-reason">${escapeHtml(reason)}</span></div></div>`;
     }).join('');
+    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 renderTrial(trial) {
-    const passedCount = trial.assertionResults.filter(r => r.passed).length;
-    const totalCount = trial.assertionResults.length;
-    const isPartial = !trial.trialPassed && !trial.isError && passedCount > 0;
-    const cls = trial.isError ? 'trial-error' : trial.trialPassed ? 'trial-pass' : isPartial ? 'trial-partial' : 'trial-fail';
-    const badge = trial.isError
-        ? '<span class="pill amber">! ERROR</span>'
-        : trial.trialPassed
-            ? '<span class="pill green">✓ PASS</span>'
-            : isPartial
-                ? `<span class="pill amber">~ PARTIAL ${passedCount}/${totalCount}</span>`
-                : '<span class="pill red">✗ NOT PASSED</span>';
-    return `<div class="trial ${cls}">
-  <div class="trial-header">Trial ${trial.id} ${badge}</div>
-  <div class="trial-assertions">${renderAssertions(trial.assertionResults)}</div>
+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];
+        if (trials && trials.length > 0 && trials[0].assertionResults.length > 0) {
+            canonical = trials[0].assertionResults;
+            break;
+        }
+    }
+    if (canonical.length === 0) {
+        return '<p class="muted">No assertions recorded.</p>';
+    }
+    const totalCols = 1 + allVersions.length;
+    const headerCells = allVersions.map(v => `<th class="variant-col">${escapeHtml(v)}</th>`).join('');
+    const rows = canonical.map((a, expIdx) => {
+        const cells = [];
+        const details = [];
+        for (const v of allVersions) {
+            const trials = v === 'baseline' ? result.baselineTrials : result.skillTrials[v];
+            const { cell, detail } = renderExpectationCell(trials, expIdx, v, result.taskId, isFunctionalEval, totalCols);
+            cells.push(cell);
+            if (detail)
+                details.push(detail);
+        }
+        return `<tr class="exp-row"><td class="exp-text">${escapeHtml(a.assertion)}</td>${cells.join('')}</tr>${details.join('')}`;
+    }).join('');
+    return `<div class="expectations-table-wrap">
+  <table class="expectations-table">
+    <thead><tr><th class="exp-col">Expectation</th>${headerCells}</tr></thead>
+    <tbody>${rows}</tbody>
+  </table>
 </div>`;
 }
 function avgTrialTokens(trials) {
@@ -135,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>
@@ -177,14 +203,7 @@ function renderTaskMiniGrid(result, isFunctionalEval) {
 function renderTaskDetails(result, isFunctionalEval) {
     const sections = [];
     sections.push(renderTaskMiniGrid(result, isFunctionalEval));
-    if (isFunctionalEval && result.baselineTrials && result.baselineTrials.length > 0) {
-        sections.push('<div class="trial-group-label">Baseline</div>');
-        sections.push(...result.baselineTrials.map(t => renderTrial(t)));
-    }
-    for (const version of Object.keys(result.skillTrials)) {
-        sections.push(`<div class="trial-group-label">${version}</div>`);
-        sections.push(...result.skillTrials[version].map(t => renderTrial(t)));
-    }
+    sections.push(renderExpectationsTable(result, isFunctionalEval));
     return `<div class="task-details" id="details-${result.taskId}">${sections.join('')}</div>`;
 }
 // ---------------------------------------------------------------------------
@@ -281,31 +300,42 @@ tr:last-child td { border-bottom: none; }
 .details-row > td { padding: 0; background: #f8fafc; }
 .task-details { display: none; padding: 12px 16px; }
 .task-details.visible { display: block; }
-.trial-group-label { font-size: 11px; font-weight: 600; text-transform: uppercase; color: #94a3b8; letter-spacing: 0.05em; margin: 8px 0 4px; }
 
-/* Trials */
-.trial { border: 1px solid #e2e8f0; border-radius: 6px; margin-bottom: 8px; overflow: hidden; }
-.trial-header { display: flex; align-items: center; gap: 8px; padding: 8px 12px; font-weight: 500; font-size: 13px; background: #f8fafc; }
-.trial-pass    .trial-header { border-left: 3px solid #22c55e; }
-.trial-partial .trial-header { border-left: 3px solid #f59e0b; }
-.trial-fail    .trial-header { border-left: 3px solid #ef4444; }
-.trial-error   .trial-header { border-left: 3px solid #f59e0b; }
-.trial-assertions { padding: 8px 12px; display: flex; flex-direction: column; gap: 6px; }
+/* Expectations × Variants table */
+.expectations-table-wrap { border: 1px solid #e2e8f0; border-radius: 6px; overflow: hidden; background: #fff; }
+.expectations-table { width: 100%; border-collapse: collapse; table-layout: fixed; }
+.expectations-table thead th { background: #f1f5f9; font-size: 10px; font-weight: 700; text-transform: uppercase; letter-spacing: 0.06em; color: #475569; padding: 10px 14px; text-align: left; border-bottom: 1px solid #e2e8f0; }
+.expectations-table thead th.exp-col { width: auto; }
+.expectations-table thead th.variant-col { width: 110px; text-align: center; }
+.expectations-table tbody td { padding: 10px 14px; border-bottom: 1px solid #f1f5f9; vertical-align: middle; font-size: 13px; }
+.expectations-table tbody tr.exp-row:last-of-type > td { border-bottom: none; }
+.exp-text { color: #1e293b; line-height: 1.4; word-break: break-word; }
 
-/* Pills */
-.pill { display: inline-block; font-size: 10px; font-weight: 700; padding: 2px 7px; border-radius: 99px; letter-spacing: 0.05em; }
-.pill.green { background: #dcfce7; color: #15803d; }
-.pill.red   { background: #fee2e2; color: #b91c1c; }
-.pill.amber { background: #fef3c7; color: #92400e; }
+.pass-cell { text-align: center; border-left: 1px solid #f1f5f9; }
+.pass-cell[data-detail] { cursor: pointer; user-select: none; transition: background 0.12s; }
+.pass-cell[data-detail]:hover { background: #f1f5f9; }
+.pass-cell.open { background: #e0f2fe; }
+.pass-cell .rate { display: block; font-size: 13px; font-weight: 700; line-height: 1.1; }
+.pass-cell .frac { display: block; font-size: 10px; font-weight: 600; color: #94a3b8; margin-top: 2px; letter-spacing: 0.03em; }
+.pass-cell.green .rate { color: #16a34a; }
+.pass-cell.amber .rate { color: #d97706; }
+.pass-cell.red   .rate { color: #dc2626; }
+
+.exp-detail-row { display: none; }
+.exp-detail-row.visible { display: table-row; }
+.exp-detail-row > td { padding: 0; background: #f8fafc; border-bottom: 1px solid #f1f5f9; }
+.exp-detail-inner { padding: 12px 14px 14px; border-left: 3px solid #3b82f6; }
+.exp-detail-header { font-size: 10px; font-weight: 700; text-transform: uppercase; letter-spacing: 0.06em; color: #64748b; margin-bottom: 8px; }
+.exp-detail-header .variant-pill { display: inline-block; background: #e0f2fe; color: #0369a1; padding: 1px 7px; border-radius: 4px; margin-left: 4px; font-weight: 700; }
+.exp-trial-line { display: flex; gap: 8px; padding: 6px 0; border-top: 1px dashed #e2e8f0; }
+.exp-trial-line:first-of-type { border-top: none; }
+.exp-trial-icon { flex-shrink: 0; font-size: 13px; font-weight: 700; line-height: 1.4; width: 16px; }
+.exp-trial-icon.pass { color: #16a34a; }
+.exp-trial-icon.fail { color: #dc2626; }
+.exp-trial-body { flex: 1; min-width: 0; font-size: 12px; color: #334155; line-height: 1.45; }
+.exp-trial-body .trial-label { font-weight: 700; color: #475569; margin-right: 4px; }
+.exp-trial-body .trial-reason { color: #64748b; }
 
-/* Assertions */
-.assertion { display: flex; gap: 8px; }
-.assert-icon { flex-shrink: 0; font-size: 14px; margin-top: 1px; }
-.assert-pass .assert-icon { color: #16a34a; }
-.assert-fail .assert-icon { color: #dc2626; }
-.assert-body { flex: 1; min-width: 0; }
-.assert-text { font-size: 13px; color: #1e293b; word-break: break-word; }
-.assert-reason { font-size: 12px; color: #64748b; margin-top: 2px; word-break: break-word; }
 .muted { color: #94a3b8; font-size: 13px; }
 </style>
 </head>
@@ -345,6 +375,16 @@ tr:last-child td { border-bottom: none; }
       btn.textContent = isOpen ? '▶' : '▼';
     });
   });
+
+  document.querySelectorAll('.pass-cell[data-detail]').forEach(function (cell) {
+    cell.addEventListener('click', function () {
+      const detailRow = document.getElementById(cell.getAttribute('data-detail'));
+      if (!detailRow) return;
+      const isOpen = detailRow.classList.contains('visible');
+      detailRow.classList.toggle('visible', !isOpen);
+      cell.classList.toggle('open', !isOpen);
+    });
+  });
 }());
 </script>
 </body>

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,6 +1,6 @@
 {
   "name": "@fede0089/skill-eval",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "description": "CLI to evaluate agent skills triggering",
   "main": "dist/index.js",
   "bin": {