@fede0089/skill-eval 1.0.0

package/dist/utils/eval-loader.js

@@ -0,0 +1,66 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ConfigError } from '../core/errors.js';
+/**
+ * Loads and merges all JSON evaluation files from a skill's evals directory.
+ * Aligned with Anthropic's recommendation to split evals by capability/regression.
+ * Supports legacy 'tasks' and 'assertions' internally while maintaining 'evals' and 'expectations' in files.
+ */
+export function loadEvalSuite(skillPath) {
+    const evalsDir = path.resolve(skillPath, 'evals');
+    if (!fs.existsSync(evalsDir)) {
+        throw new ConfigError(`Could not find evals directory at ${evalsDir}`);
+    }
+    const files = fs.readdirSync(evalsDir).filter(file => file.endsWith('.json'));
+    if (files.length === 0) {
+        throw new ConfigError(`No JSON evaluation files found in ${evalsDir}`);
+    }
+    let mergedSkillName = '';
+    const mergedTasks = [];
+    for (const file of files) {
+        const filePath = path.join(evalsDir, file);
+        let config;
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            config = JSON.parse(raw);
+        }
+        catch (err) {
+            throw new ConfigError(`Failed to parse ${file}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const skill_name = config.skill_name;
+        // Standard input uses 'evals' key
+        const rawEvals = config.evals || config.tasks;
+        if (!skill_name || !Array.isArray(rawEvals)) {
+            throw new ConfigError(`Invalid format in ${file}. Expected 'skill_name' and 'evals' array.`);
+        }
+        if (!mergedSkillName) {
+            mergedSkillName = skill_name;
+        }
+        else if (mergedSkillName !== skill_name) {
+            throw new ConfigError(`Skill name mismatch in ${file}. Expected '${mergedSkillName}' but found '${skill_name}'.`);
+        }
+        // Map input fields to internal terminology
+        const mappedTasks = rawEvals.map((e) => {
+            if (e.id === undefined || typeof e.id !== 'number') {
+                throw new ConfigError(`Invalid task ID in ${file}. ID must be a number.`);
+            }
+            return {
+                id: e.id,
+                prompt: e.prompt,
+                expected_output: e.expected_output,
+                assertions: e.expectations || e.assertions,
+                files: e.files
+            };
+        });
+        mergedTasks.push(...mappedTasks);
+    }
+    if (mergedTasks.length === 0) {
+        throw new ConfigError(`No evaluations found in any of the JSON files in ${evalsDir}`);
+    }
+    return {
+        skill_name: mergedSkillName,
+        tasks: mergedTasks
+    };
+}
+// Backwards compatibility alias
+export const loadEvals = loadEvalSuite;

package/dist/utils/exec.js

@@ -0,0 +1,9 @@
+import { execSync, spawnSync } from 'child_process';
+export const executor = {
+    execSync(command, options) {
+        return execSync(command, options);
+    },
+    spawnSync(command, args, options) {
+        return spawnSync(command, args, options);
+    }
+};

package/dist/utils/logger.js

@@ -0,0 +1,80 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+export class Logger {
+    static info(message) {
+        console.log(chalk.blue('ℹ'), message);
+    }
+    static error(message, error) {
+        console.error(chalk.red('✖'), chalk.red(message), error || '');
+    }
+    static warn(message) {
+        console.warn(chalk.yellow('⚠'), chalk.yellow(message));
+    }
+    static success(message) {
+        console.log(chalk.green('✔'), chalk.green(message));
+    }
+    static debug(message) {
+        if (process.env.DEBUG) {
+            console.log(chalk.gray('[Debug]'), message);
+        }
+    }
+    static trace(error) {
+        if (typeof error === 'string') {
+            console.error(chalk.red('Trace:'), error);
+            return;
+        }
+        console.error(chalk.red.bold(`\nTrace: ${error.message}`));
+        if (error.stack) {
+            const stack = error.stack
+                .split('\n')
+                .slice(1)
+                .map(line => chalk.gray(line))
+                .join('\n');
+            console.error(stack);
+        }
+        console.error('');
+    }
+    static write(message) {
+        process.stdout.write(message);
+    }
+    static table(data, options = {}) {
+        const table = new Table({
+            chars: {
+                'top': '─', 'top-mid': '┬', 'top-left': '┌', 'top-right': '┐',
+                'bottom': '─', 'bottom-mid': '┴', 'bottom-left': '└', 'bottom-right': '┘',
+                'left': '│', 'left-mid': '├', 'mid': '─', 'mid-mid': '┼',
+                'right': '│', 'right-mid': '┤', 'middle': '│'
+            },
+            style: { head: ['cyan'], border: ['gray'] },
+            ...options
+        });
+        table.push(...data);
+        console.log(table.toString());
+    }
+}
+export class Spinner {
+    spinner;
+    constructor(prefix = '   Running agent') {
+        this.spinner = ora({
+            text: prefix,
+            color: 'cyan',
+            spinner: 'dots'
+        });
+    }
+    start() {
+        this.spinner.start();
+    }
+    updateLog(log) {
+        // Sanitize log to single line and limit length
+        const sanitized = log.replace(/\n/g, ' ').trim();
+        const truncated = sanitized.length > 60 ? sanitized.substring(0, 57) + '...' : sanitized;
+        this.spinner.text = `${this.spinner.text.split(' [')[0]} [${truncated}]`;
+    }
+    stop(finalMessage = 'Done.') {
+        this.spinner.succeed(finalMessage);
+    }
+    stopAndClear() {
+        this.spinner.stop();
+    }
+}

package/dist/utils/ndjson.js

@@ -0,0 +1,85 @@
+/**
+ * Parses Newline-Delimited JSON (NDJSON) output into an array of events.
+ * Each non-empty line is parsed as a complete JSON value.
+ * Lines that are not valid JSON (e.g. ANSI codes, status text) are skipped silently.
+ * Unknown event types (not in NdjsonEvent union) are cast and silently ignored by callers.
+ */
+export function parseNdjsonEvents(output) {
+    const events = [];
+    for (const line of output.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            events.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Non-JSON line — skip silently
+        }
+    }
+    return events;
+}
+/**
+ * Parses a Gemini CLI stream-json stdout blob into a clean result.
+ * Returns { error } if the result event signals failure.
+ * Returns { response } with joined assistant text on success.
+ * Returns null if no result event is present (non-stream output).
+ */
+export function parseStreamResult(output) {
+    let deltaBuffer = '';
+    const completedParts = [];
+    let resultEvent = null;
+    for (const event of parseNdjsonEvents(output)) {
+        if (event.type === 'message' && event.role === 'assistant' && typeof event.content === 'string') {
+            if (event.delta) {
+                // Streaming fragment — concatenate directly, no separator
+                deltaBuffer += event.content;
+            }
+            else {
+                // Complete message turn — flush delta buffer first, then add as a separate turn
+                if (deltaBuffer) {
+                    completedParts.push(deltaBuffer);
+                    deltaBuffer = '';
+                }
+                completedParts.push(event.content);
+            }
+        }
+        else if (event.type === 'result') {
+            resultEvent = event;
+        }
+    }
+    // Flush any trailing delta fragments
+    if (deltaBuffer) {
+        completedParts.push(deltaBuffer);
+    }
+    if (!resultEvent)
+        return null;
+    if (resultEvent.status === 'error') {
+        const msg = resultEvent.error?.message || 'Agent run failed';
+        return { error: msg };
+    }
+    const text = completedParts.join('\n').trim() ||
+        (typeof resultEvent.response === 'string' ? resultEvent.response : '');
+    return { response: text };
+}
+/**
+ * Extracts token consumption stats from a Gemini CLI stream-json stdout blob.
+ * Looks for a result event with a stats.total_tokens field.
+ * Returns null if no such event is found or stats are absent.
+ */
+export function parseTokenStats(output) {
+    for (const event of parseNdjsonEvents(output)) {
+        if (event.type === 'result' && event.stats) {
+            const s = event.stats;
+            if (typeof s.total_tokens === 'number') {
+                return {
+                    totalTokens: s.total_tokens,
+                    inputTokens: typeof s.input_tokens === 'number' ? s.input_tokens : 0,
+                    outputTokens: typeof s.output_tokens === 'number' ? s.output_tokens : 0,
+                    cachedTokens: typeof s.cached === 'number' ? s.cached : 0,
+                };
+            }
+        }
+    }
+    return null;
+}

package/dist/utils/table-renderer.js

@@ -0,0 +1,229 @@
+import chalk from 'chalk';
+import * as path from 'path';
+import { Logger } from './logger.js';
+import { computePassAtK } from '../core/statistics.js';
+/**
+ * Returns a color-coded assertion pass rate string for a set of trials.
+ * Only non-error trials contribute assertions to the rate.
+ * Color thresholds: ≥80% green, ≥50% yellow, <50% red.
+ */
+function formatAssertionRate(trials) {
+    if (trials.length === 0)
+        return chalk.gray('—');
+    const allError = trials.every(t => t.isError);
+    const someError = trials.some(t => t.isError);
+    const relevant = trials.filter(t => !t.isError);
+    const total = relevant.reduce((s, t) => s + t.assertionResults.length, 0);
+    const passed = relevant.reduce((s, t) => s + t.assertionResults.filter(r => r.passed).length, 0);
+    const pct = total > 0 ? Math.round((passed / total) * 100) : 0;
+    if (allError)
+        return chalk.yellow('Error');
+    if (someError)
+        return chalk.yellow(`${pct}%*`);
+    if (pct >= 80)
+        return chalk.green(`${pct}%`);
+    if (pct >= 50)
+        return chalk.yellow(`${pct}%`);
+    return chalk.red(`${pct}%`);
+}
+/**
+ * Formats a duration in milliseconds for human-readable display.
+ * e.g. 45000 → "45s", 90000 → "1m 30s"
+ */
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const s = Math.round(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rem = s % 60;
+    return rem > 0 ? `${m}m ${rem}s` : `${m}m`;
+}
+/**
+ * Formats a token count for human-readable display.
+ * Numbers >= 1M are shown as "1.2M", >= 1K as "119K", else as-is.
+ */
+export function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${Math.round(n / 1_000)}K`;
+    return `${n}`;
+}
+function formatTokenStatsLine(stats) {
+    const total = formatTokens(stats.avgTotal);
+    const input = formatTokens(stats.avgInput);
+    const output = formatTokens(stats.avgOutput);
+    const cached = formatTokens(stats.avgCached);
+    return `${total} total  (${input} input + ${output} output,  ${cached} cached)`;
+}
+/**
+ * Returns a color-coded pass@1 string for a set of trials:
+ * - All errored  → yellow "Error"
+ * - Some errored → yellow "X%*"  (unreliable, partial measurement)
+ * - None errored → green  "X%"   (reliable measurement)
+ */
+function formatPassAt1(trials) {
+    const allError = trials.length > 0 && trials.every(t => t.isError);
+    const someError = trials.some(t => t.isError);
+    const p1 = Math.round(computePassAtK(trials, 1) * 100);
+    if (allError)
+        return chalk.yellow('Error');
+    if (someError)
+        return chalk.yellow(`${p1}%*`);
+    return chalk.green(`${p1}%`);
+}
+const BOX_INNER = 56; // visible chars between │ and │ (one space padding each side)
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+function boxLine(content = '') {
+    const visible = stripAnsi(content).length;
+    const pad = Math.max(0, BOX_INNER - visible);
+    return chalk.gray('│') + ' ' + content + ' '.repeat(pad) + ' ' + chalk.gray('│');
+}
+function boxLabel(key, value) {
+    const keyPart = chalk.gray(key.padEnd(11));
+    return boxLine(keyPart + ' ' + chalk.white(value));
+}
+/**
+ * Renders a styled run-config header before the evaluation UI starts.
+ * Always shown regardless of debug mode.
+ */
+export function renderRunHeader(config) {
+    const { command, skillName, agent, workspace, tasks, trials, maxAgents, timeoutMs, runDir, evalId } = config;
+    let timeoutStr = 'None';
+    if (timeoutMs && timeoutMs > 0) {
+        const timeoutSec = timeoutMs / 1000;
+        timeoutStr = timeoutSec % 60 === 0 ? `${timeoutSec / 60}m` : `${timeoutSec}s`;
+    }
+    const relRunDir = path.relative(workspace, runDir);
+    const maxOutputLen = BOX_INNER - 13; // 11 label + 2 spaces
+    const outputStr = relRunDir.length > maxOutputLen ? relRunDir.slice(0, maxOutputLen - 1) + '…' : relRunDir;
+    const titleLabel = 'skill-eval';
+    const dashes = '─'.repeat(BOX_INNER - titleLabel.length);
+    const top = chalk.gray('┌─ ') + chalk.bold(titleLabel) + ' ' + chalk.gray(dashes + '┐');
+    const bottom = chalk.gray('└' + '─'.repeat(BOX_INNER + 2) + '┘');
+    const commandPart = evalId !== undefined ? `${command}  ·  eval #${evalId}` : command;
+    const title = chalk.bold.cyan(skillName) + chalk.gray(`  ·  ${commandPart}`);
+    const runLine = `${tasks} task${tasks !== 1 ? 's' : ''}  ·  ${trials} trial${trials !== 1 ? 's' : ''}  ·  agents ${maxAgents}`;
+    process.stdout.write('\n');
+    process.stdout.write(top + '\n');
+    process.stdout.write(boxLine(title) + '\n');
+    process.stdout.write(boxLine() + '\n');
+    process.stdout.write(boxLabel('agent', agent) + '\n');
+    process.stdout.write(boxLabel('run', runLine) + '\n');
+    process.stdout.write(boxLabel('timeout', timeoutStr) + '\n');
+    process.stdout.write(boxLabel('output', outputStr) + '\n');
+    process.stdout.write(bottom + '\n\n');
+}
+/**
+ * Renders a trigger evaluation summary table and rate line to the terminal.
+ * Accepts a full EvalSuiteReport so it can be called from both live commands
+ * and the `show` command (which reads from disk).
+ */
+export function renderTriggerTable(report) {
+    const { results, metrics } = report;
+    const numTrials = metrics.numTrials || 1;
+    const tableData = numTrials > 1
+        ? [['ID', 'Prompt', 'Trials', 'success rate']]
+        : [['ID', 'Prompt', 'success rate']];
+    let hasPartialErrors = false;
+    for (const result of results) {
+        const promptSnippet = result.prompt.substring(0, 40) + (result.prompt.length > 40 ? '...' : '');
+        const p1Cell = formatPassAt1(result.trials);
+        const someError = result.trials.some(t => t.isError);
+        const allError = result.trials.length > 0 && result.trials.every(t => t.isError);
+        if (someError && !allError)
+            hasPartialErrors = true;
+        if (numTrials > 1) {
+            const errorCount = result.trials.filter(t => t.isError).length;
+            const passedCount = result.trials.filter(t => t.trialPassed).length;
+            const trialsBase = `${passedCount}/${result.trials.length}`;
+            const trialsStr = errorCount > 0 ? `${trialsBase} (${errorCount}!)` : trialsBase;
+            const trials = result.score === 1.0 ? chalk.green(trialsStr) : errorCount > 0 ? chalk.yellow(trialsStr) : chalk.red(trialsStr);
+            tableData.push([result.taskId.toString(), promptSnippet, trials, p1Cell]);
+        }
+        else {
+            tableData.push([result.taskId.toString(), promptSnippet, p1Cell]);
+        }
+    }
+    Logger.table(tableData);
+    if (hasPartialErrors) {
+        Logger.write(chalk.yellow('\n   * Some trials did not complete due to infrastructure errors. success rate is computed over the trials that ran.'));
+    }
+    const percentage = Math.round((metrics.passAtK || 0) * 100);
+    Logger.write(`\n   Trigger Success Rate:   ${percentage}%`);
+    const withSkillTokenStats = metrics.tokenStats?.withSkill;
+    if (withSkillTokenStats) {
+        Logger.write(`\n   Avg Tokens:             ${formatTokenStatsLine(withSkillTokenStats)}`);
+    }
+    const withSkillDurationStats = metrics.durationStats?.withSkill;
+    if (withSkillDurationStats) {
+        Logger.write(`\n   Avg Time:               ${formatDuration(withSkillDurationStats.avgMs)}`);
+    }
+}
+/**
+ * Renders a functional evaluation summary table and rate lines to the terminal.
+ */
+export function renderFunctionalTable(report) {
+    const { results, metrics } = report;
+    const tableData = [['ID', 'Prompt', 'Without Skill', 'With Skill']];
+    let hasPartialErrors = false;
+    for (const result of results) {
+        const promptSnippet = result.prompt.substring(0, 40) + (result.prompt.length > 40 ? '...' : '');
+        const withoutSkillTrials = result.withoutSkillTrials || [];
+        const withSkillTrials = result.trials;
+        const baselineSomeError = withoutSkillTrials.some(t => t.isError);
+        const baselineAllError = withoutSkillTrials.length > 0 && withoutSkillTrials.every(t => t.isError);
+        const withSkillSomeError = withSkillTrials.some(t => t.isError);
+        const withSkillAllError = withSkillTrials.length > 0 && withSkillTrials.every(t => t.isError);
+        if ((baselineSomeError && !baselineAllError) || (withSkillSomeError && !withSkillAllError))
+            hasPartialErrors = true;
+        tableData.push([
+            result.taskId.toString(),
+            promptSnippet,
+            formatAssertionRate(withoutSkillTrials),
+            formatAssertionRate(withSkillTrials),
+        ]);
+    }
+    Logger.table(tableData);
+    if (hasPartialErrors) {
+        Logger.write(chalk.yellow('\n   * Some trials did not complete due to infrastructure errors. success rate is computed over the trials that ran.'));
+    }
+    const withoutSkillPercentage = Math.round(((metrics.withoutSkillAssertionPassRate ?? metrics.withoutSkillPassAtK) || 0) * 100);
+    const withSkillPercentage = Math.round(((metrics.assertionPassRate ?? metrics.passAtK) || 0) * 100);
+    Logger.write(`\n   Without Skill Rate:   ${withoutSkillPercentage}%`);
+    Logger.write(`\n   With Skill Rate:      ${withSkillPercentage}%`);
+    const baselineTokenStats = metrics.tokenStats?.withoutSkill;
+    const withSkillTokenStats = metrics.tokenStats?.withSkill;
+    if (baselineTokenStats || withSkillTokenStats) {
+        if (baselineTokenStats)
+            Logger.write(`\n   Tokens (w/o skill):   ${formatTokenStatsLine(baselineTokenStats)}`);
+        if (withSkillTokenStats)
+            Logger.write(`\n   Tokens (w/ skill):    ${formatTokenStatsLine(withSkillTokenStats)}`);
+        if (baselineTokenStats && withSkillTokenStats && baselineTokenStats.avgTotal > 0) {
+            const delta = withSkillTokenStats.avgTotal - baselineTokenStats.avgTotal;
+            const deltaSign = delta >= 0 ? '+' : '';
+            const deltaPct = Math.round((delta / baselineTokenStats.avgTotal) * 100);
+            const deltaStr = `${deltaSign}${formatTokens(Math.abs(delta))} (${deltaSign}${deltaPct}%)`;
+            Logger.write(`\n   Token Delta:          ${delta >= 0 ? chalk.yellow(deltaStr) : chalk.green(deltaStr)}`);
+        }
+    }
+    const baselineDurationStats = metrics.durationStats?.withoutSkill;
+    const withSkillDurationStats = metrics.durationStats?.withSkill;
+    if (baselineDurationStats || withSkillDurationStats) {
+        if (baselineDurationStats)
+            Logger.write(`\n   Time (w/o skill):     ${formatDuration(baselineDurationStats.avgMs)} avg`);
+        if (withSkillDurationStats)
+            Logger.write(`\n   Time (w/ skill):      ${formatDuration(withSkillDurationStats.avgMs)} avg`);
+        if (baselineDurationStats && withSkillDurationStats && baselineDurationStats.avgMs > 0) {
+            const delta = withSkillDurationStats.avgMs - baselineDurationStats.avgMs;
+            const deltaSign = delta >= 0 ? '+' : '';
+            const deltaPct = Math.round((delta / baselineDurationStats.avgMs) * 100);
+            const deltaStr = `${deltaSign}${formatDuration(Math.abs(delta))} (${deltaSign}${deltaPct}%)`;
+            Logger.write(`\n   Time Delta:           ${delta >= 0 ? chalk.yellow(deltaStr) : chalk.green(deltaStr)}`);
+        }
+    }
+}

package/dist/utils/ui.js

@@ -0,0 +1,166 @@
+import { Listr } from 'listr2';
+function sanitizeLog(log, maxLen = 50) {
+    const sanitized = log.replace(/\n/g, ' ').trim();
+    return sanitized.length > maxLen ? sanitized.substring(0, maxLen - 3) + '...' : sanitized;
+}
+/**
+ * Listr implementation for rendering parallel task progress
+ */
+export class ListrEvalUI {
+    tasks = [];
+    addTask(descriptor) {
+        const numTrials = descriptor.subtaskLabels
+            ? descriptor.subtaskLabels.length
+            : (descriptor.numTrials ?? 0);
+        if (numTrials <= 1) {
+            // Single-trial path: existing behaviour unchanged
+            this.tasks.push({
+                title: descriptor.title,
+                task: async (ctx, task) => {
+                    let taskDone = false;
+                    const evalCtx = {
+                        updateLog: (log) => {
+                            if (taskDone)
+                                return;
+                            task.output = sanitizeLog(log);
+                        }
+                    };
+                    try {
+                        await descriptor.task(evalCtx);
+                    }
+                    catch (error) {
+                        if (error instanceof Error)
+                            error.message = '';
+                        throw error;
+                    }
+                    finally {
+                        taskDone = true;
+                    }
+                }
+            });
+            return;
+        }
+        // Multi-trial path: one listr2 subtask per trial, each backed by a deferred promise
+        this.tasks.push({
+            title: descriptor.title,
+            task: (ctx, parentTask) => {
+                const deferreds = [];
+                const outputSetters = Array.from({ length: numTrials }, () => () => { });
+                const titleSetters = Array.from({ length: numTrials }, () => () => { });
+                const titleSetterReady = new Array(numTrials).fill(false);
+                const pendingTitle = new Array(numTrials).fill(undefined);
+                const trialDone = new Array(numTrials).fill(false);
+                const subtaskBaseLabels = descriptor.subtaskLabels
+                    ? descriptor.subtaskLabels
+                    : Array.from({ length: numTrials }, (_, idx) => `Trial ${idx + 1}`);
+                const subtasks = Array.from({ length: numTrials }, (_, idx) => {
+                    let resolve, reject;
+                    const promise = new Promise((res, rej) => {
+                        resolve = res;
+                        reject = rej;
+                    });
+                    deferreds.push({ resolve, reject });
+                    return {
+                        title: subtaskBaseLabels[idx],
+                        task: async (_, subtask) => {
+                            outputSetters[idx] = (s) => {
+                                subtask.output = s;
+                            };
+                            titleSetters[idx] = (s) => {
+                                subtask.title = s;
+                            };
+                            titleSetterReady[idx] = true;
+                            if (pendingTitle[idx] !== undefined) {
+                                subtask.title = pendingTitle[idx];
+                                pendingTitle[idx] = undefined;
+                            }
+                            await promise;
+                        }
+                    };
+                });
+                const multiCtx = {
+                    getTrialCtx: (trialId) => ({
+                        updateLog: (log) => {
+                            const i = trialId - 1;
+                            if (trialDone[i])
+                                return;
+                            const title = `${subtaskBaseLabels[i]} — ${sanitizeLog(log)}`;
+                            if (titleSetterReady[i]) {
+                                titleSetters[i](title);
+                            }
+                            else {
+                                pendingTitle[i] = title;
+                            }
+                        }
+                    }),
+                    markTrialComplete: (trialId, passed, failureReason, isError, assertionsPassed, assertionsTotal) => {
+                        const i = trialId - 1;
+                        if (trialDone[i])
+                            return;
+                        trialDone[i] = true;
+                        if (passed) {
+                            titleSetters[i](`${subtaskBaseLabels[i]} — passed`);
+                            deferreds[i].resolve();
+                        }
+                        else {
+                            if (isError) {
+                                titleSetters[i](`${subtaskBaseLabels[i]} — error`);
+                                outputSetters[i]('(!) ERROR');
+                            }
+                            else if (assertionsPassed !== undefined && assertionsTotal !== undefined && assertionsPassed > 0) {
+                                titleSetters[i](`${subtaskBaseLabels[i]} — partial ${assertionsPassed}/${assertionsTotal}`);
+                            }
+                            else {
+                                titleSetters[i](`${subtaskBaseLabels[i]} — not-passed`);
+                            }
+                            deferreds[i].reject(new Error(''));
+                        }
+                    }
+                };
+                // Fire-and-forget: task runs concurrently with the subtask lifecycle.
+                // Aggregation inside descriptor.task() completes before ui.run() resolves
+                // because markTrialComplete() is called before each .then() returns,
+                // so all deferreds are resolved before Promise.all() inside descriptor.task() resolves.
+                descriptor.task({ updateLog: () => { } }, multiCtx).catch((unexpectedError) => {
+                    // Reject any pending deferreds so subtasks don't hang
+                    const err = unexpectedError instanceof Error
+                        ? unexpectedError
+                        : new Error(String(unexpectedError));
+                    deferreds.forEach((d, i) => {
+                        if (!trialDone[i]) {
+                            trialDone[i] = true;
+                            try {
+                                d.reject(err);
+                            }
+                            catch (_) { }
+                        }
+                    });
+                });
+                return parentTask.newListr(subtasks, { concurrent: true, exitOnError: false });
+            }
+        });
+    }
+    async run(concurrency) {
+        if (this.tasks.length === 0)
+            return;
+        // Use simple renderer in non-TTY or tests to avoid hangs and provide clearer logs
+        const isTTY = process.stdout.isTTY;
+        const isTest = process.env.NODE_ENV === 'test' || process.env.CI === 'true';
+        const listr = new Listr(this.tasks, {
+            concurrent: concurrency,
+            exitOnError: false, // Continue other tasks if one fails
+            renderer: (isTTY && !isTest) ? 'default' : 'verbose',
+            rendererOptions: {
+                collapseSubtasks: false,
+                formatOutput: 'wrap'
+            }
+        });
+        try {
+            await listr.run();
+        }
+        catch (error) {
+            // Listr throws if any task fails even with exitOnError: false.
+            // We catch it here because we handle the results/errors ourselves in the caller.
+        }
+    }
+}