bktide 1.0.1755559112 → 1.0.1755639164

package/dist/formatters/build-detail/PlainTextFormatter.js

@@ -1,7 +1,7 @@
 import { BaseBuildDetailFormatter } from './Formatter.js';
 import { formatDistanceToNow } from 'date-fns';
 import { htmlToText } from 'html-to-text';
-import { formatEmptyState, formatError, SEMANTIC_COLORS, formatBuildStatus } from '../../ui/theme.js';
+import { formatEmptyState, formatError, SEMANTIC_COLORS, formatBuildStatus, formatTips, TipStyle, getStateIcon, getAnnotationIcon, getProgressIcon, BUILD_STATUS_THEME } from '../../ui/theme.js';
 // Standard emoji mappings only
 // Only map universally recognized emoji codes, not Buildkite-specific ones
 const STANDARD_EMOJI = {
@@ -127,28 +127,40 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
         return formatError(options?.errorMessage || 'Unknown error');
     }
     formatSummaryLine(build) {
-        const status = this.getStatusIcon(build.state);
+        const statusIcon = this.getStatusIcon(build.state);
+        const coloredIcon = this.colorizeStatusIcon(statusIcon, build.state);
         const duration = this.formatDuration(build);
         const age = this.formatAge(build.createdAt);
-        return `${status} #${build.number} ${build.state.toLowerCase()} • ${duration} • ${build.branch} • ${age}`;
+        const stateFormatted = formatBuildStatus(build.state, { useSymbol: false });
+        const branch = SEMANTIC_COLORS.identifier(build.branch);
+        return `${coloredIcon} ${SEMANTIC_COLORS.label(`#${build.number}`)} ${stateFormatted} • ${duration} • ${branch} • ${age}`;
     }
     formatPassedBuild(build, options) {
         const lines = [];
         // Header line
         lines.push(this.formatHeader(build));
         lines.push(this.formatCommitInfo(build));
+        lines.push(''); // Blank line after commit info
         // Show annotations summary if present
         if (build.annotations?.edges?.length > 0) {
-            lines.push('');
             lines.push(this.formatAnnotationSummary(build.annotations.edges));
+        }
+        // Jobs summary
+        if (build.jobs?.edges?.length > 0) {
+            if (build.annotations?.edges?.length > 0) {
+                lines.push(''); // Add space between annotations and steps
+            }
+            lines.push(this.formatJobSummary(build.jobs, build.state));
             if (!options?.annotations) {
-                lines.push(SEMANTIC_COLORS.dim(`→ bin/bktide build ${build.number} --annotations  # view annotations`));
+                lines.push('');
+                const tips = formatTips(['Use --annotations to view annotation details'], TipStyle.GROUPED);
+                lines.push(tips);
             }
         }
         // Show annotations detail if requested
         if (options?.annotations) {
             lines.push('');
-            lines.push(this.formatAnnotationDetails(build.annotations.edges, options));
+            lines.push(this.formatAnnotationDetails(build.annotations.edges));
         }
         return lines.join('\n');
     }
@@ -158,15 +170,18 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
         lines.push(this.formatHeader(build));
         lines.push(this.formatCommitInfo(build));
         lines.push('');
-        // Failed jobs summary
-        const failedJobs = this.getFailedJobs(build.jobs?.edges);
-        if (failedJobs.length > 0) {
-            lines.push(this.formatFailedJobsSummary(failedJobs));
-        }
-        // Annotation summary
+        const allHints = [];
+        // Annotation summary (first, as it appears first in UI)
         if (build.annotations?.edges?.length > 0) {
             lines.push(this.formatAnnotationSummary(build.annotations.edges));
         }
+        // Jobs summary
+        if (build.jobs?.edges?.length > 0) {
+            if (build.annotations?.edges?.length > 0) {
+                lines.push(''); // Add space between annotations and steps
+            }
+            lines.push(this.formatJobSummary(build.jobs, build.state));
+        }
         // Show detailed job info if requested
         if (options?.jobs || options?.failed) {
             lines.push('');
@@ -175,15 +190,24 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
         // Show annotations detail if requested
         if (options?.annotations) {
             lines.push('');
-            lines.push(this.formatAnnotationDetails(build.annotations.edges, options));
+            lines.push(this.formatAnnotationDetails(build.annotations.edges));
         }
-        // Hints for more info (no Tips label)
+        // Collect all hints for more info
+        const failedJobs = this.getFailedJobs(build.jobs?.edges);
         if (!options?.failed && failedJobs.length > 0) {
-            lines.push('');
-            lines.push(SEMANTIC_COLORS.dim(`→ bin/bktide build ${build.number} --failed  # show failure details`));
+            allHints.push('Use --failed to show failure details');
         }
         if (!options?.annotations && build.annotations?.edges?.length > 0) {
-            lines.push(SEMANTIC_COLORS.dim(`→ bin/bktide build ${build.number} --annotations  # view annotations`));
+            allHints.push('Use --annotations to view annotation details');
+        }
+        // Add hint about incomplete step data if truncated
+        if (!options?.jobs && build.jobs?.pageInfo?.hasNextPage) {
+            allHints.push('Use --jobs to fetch all step data (currently showing first 100 only)');
+        }
+        // Display all hints together
+        if (allHints.length > 0) {
+            lines.push('');
+            lines.push(formatTips(allHints, TipStyle.GROUPED));
         }
         return lines.join('\n');
     }
@@ -193,20 +217,38 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
         lines.push(this.formatHeader(build));
         lines.push(this.formatCommitInfo(build));
         lines.push('');
-        // Progress information
-        const jobStats = this.getJobStats(build.jobs?.edges);
-        lines.push(`Progress: ${SEMANTIC_COLORS.count(String(jobStats.completed))}/${jobStats.total} complete, ${SEMANTIC_COLORS.info(String(jobStats.running))} running, ${jobStats.queued} queued`);
+        // Annotations first (if any)
+        if (build.annotations?.edges?.length > 0) {
+            lines.push(this.formatAnnotationSummary(build.annotations.edges));
+        }
+        // Jobs summary with progress
+        if (build.jobs?.edges?.length > 0) {
+            if (build.annotations?.edges?.length > 0) {
+                lines.push(''); // Add space between annotations and steps
+            }
+            lines.push(this.formatJobSummary(build.jobs, build.state));
+        }
         // Show running jobs
         const runningJobs = this.getRunningJobs(build.jobs?.edges);
         if (runningJobs.length > 0) {
             const labels = runningJobs.map(j => this.parseEmoji(j.node.label)).join(', ');
             lines.push(`${SEMANTIC_COLORS.info('Running')}: ${labels}`);
         }
+        // Annotation summary
+        if (build.annotations?.edges?.length > 0) {
+            lines.push('');
+            lines.push(this.formatAnnotationSummary(build.annotations.edges));
+        }
         // Show job details if requested
         if (options?.jobs) {
             lines.push('');
             lines.push(this.formatJobDetails(build.jobs?.edges, options));
         }
+        // Show annotations detail if requested
+        if (options?.annotations) {
+            lines.push('');
+            lines.push(this.formatAnnotationDetails(build.annotations.edges));
+        }
         return lines.join('\n');
     }
     formatBlockedBuild(build, options) {
@@ -215,21 +257,33 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
         lines.push(this.formatHeader(build));
         lines.push(this.formatCommitInfo(build));
         lines.push('');
+        // Annotations first (if any)
+        if (build.annotations?.edges?.length > 0) {
+            lines.push(this.formatAnnotationSummary(build.annotations.edges));
+        }
+        // Jobs summary
+        if (build.jobs?.edges?.length > 0) {
+            if (build.annotations?.edges?.length > 0) {
+                lines.push(''); // Add space between annotations and steps
+            }
+            lines.push(this.formatJobSummary(build.jobs, build.state));
+        }
         // Blocked information
         const blockedJobs = this.getBlockedJobs(build.jobs?.edges);
         if (blockedJobs.length > 0) {
-            lines.push(`🚫 Blocked: "${blockedJobs[0].node.label}" (manual unblock required)`);
-        }
-        // Show jobs summary
-        const jobStats = this.getJobStats(build.jobs?.edges);
-        if (jobStats.completed > 0) {
-            lines.push(`✅ ${jobStats.completed} jobs passed before block`);
+            lines.push('');
+            lines.push(`${getProgressIcon('BLOCKED_MESSAGE')} Blocked: "${blockedJobs[0].node.label}" (manual unblock required)`);
         }
         // Show job details if requested
         if (options?.jobs) {
             lines.push('');
             lines.push(this.formatJobDetails(build.jobs?.edges, options));
         }
+        // Show annotations detail if requested
+        if (options?.annotations) {
+            lines.push('');
+            lines.push(this.formatAnnotationDetails(build.annotations.edges));
+        }
         return lines.join('\n');
     }
     formatCanceledBuild(build, options) {
@@ -238,14 +292,23 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
         lines.push(this.formatHeader(build));
         lines.push(this.formatCommitInfo(build));
         lines.push('');
+        // Annotations first (if any)
+        if (build.annotations?.edges?.length > 0) {
+            lines.push(this.formatAnnotationSummary(build.annotations.edges));
+        }
+        // Jobs summary
+        if (build.jobs?.edges?.length > 0) {
+            if (build.annotations?.edges?.length > 0) {
+                lines.push(''); // Add space between annotations and steps
+            }
+            lines.push(this.formatJobSummary(build.jobs, build.state));
+        }
         // Canceled information
         if (build.createdBy) {
+            lines.push('');
             const creator = build.createdBy.name || build.createdBy.email;
             lines.push(`Canceled by: ${creator}`);
         }
-        // Show jobs summary
-        const jobStats = this.getJobStats(build.jobs?.edges);
-        lines.push(`Completed: ${jobStats.completed}/${jobStats.total} jobs before cancellation`);
         // Show job details if requested
         if (options?.jobs) {
             lines.push('');
@@ -268,62 +331,185 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
         lines.push(`  Organization: ${build.organization?.name || 'Unknown'}`);
         lines.push(`  Pipeline: ${build.pipeline?.name || 'Unknown'}`);
         if (build.pullRequest) {
-            lines.push(`  Pull Request: #${build.pullRequest.number}`);
+            // Try to construct PR URL from repository URL
+            const repoUrl = build.pipeline?.repository?.url;
+            if (repoUrl && repoUrl.includes('github.com')) {
+                // Extract owner/repo from various GitHub URL formats
+                const match = repoUrl.match(/github\.com[/:]([\w-]+)\/([\w-]+)/);
+                if (match && build.pullRequest.id) {
+                    // Extract PR number from GraphQL ID if possible
+                    // GitHub PR IDs often contain the number
+                    const prUrl = `https://github.com/${match[1]}/${match[2]}/pull/${build.pullRequest.id}`;
+                    lines.push(`  Pull Request: ${SEMANTIC_COLORS.url(prUrl)}`);
+                }
+                else {
+                    lines.push(`  Pull Request: ${build.pullRequest.id}`);
+                }
+            }
+            else {
+                lines.push(`  Pull Request: ${build.pullRequest.id}`);
+            }
         }
         if (build.triggeredFrom) {
             lines.push(`  Triggered from: ${build.triggeredFrom.pipeline?.name} #${build.triggeredFrom.number}`);
         }
         lines.push('');
-        // Jobs section
-        lines.push('Jobs:');
+        // Steps section
+        lines.push('Steps:');
         lines.push(this.formatJobDetails(build.jobs?.edges, { ...options, full: true }));
         // Annotations section
         if (build.annotations?.edges?.length > 0) {
             lines.push('');
             lines.push('Annotations:');
-            lines.push(this.formatAnnotationDetails(build.annotations.edges, { ...options, annotationsFull: true }));
+            lines.push(this.formatAnnotationDetails(build.annotations.edges));
         }
         return lines.join('\n');
     }
     formatHeader(build) {
-        const status = this.getStatusIcon(build.state);
+        const statusIcon = this.getStatusIcon(build.state);
+        // Apply appropriate color to the icon based on the state
+        const coloredIcon = this.colorizeStatusIcon(statusIcon, build.state);
         const stateFormatted = formatBuildStatus(build.state, { useSymbol: false });
         const duration = this.formatDuration(build);
-        const age = this.formatAge(build.createdAt);
-        const branch = SEMANTIC_COLORS.identifier(build.branch);
-        return `${status} ${SEMANTIC_COLORS.label(`#${build.number}`)} ${stateFormatted} • ${duration} • ${branch} • ${age}`;
+        // Get first line of commit message
+        const message = build.message || 'No commit message';
+        const firstLineMessage = message.split('\n')[0];
+        const truncatedMessage = firstLineMessage.length > 80 ? firstLineMessage.substring(0, 77) + '...' : firstLineMessage;
+        return `${coloredIcon} ${stateFormatted} ${truncatedMessage} ${SEMANTIC_COLORS.dim(`#${build.number}`)} ${SEMANTIC_COLORS.dim(duration)}`;
     }
     formatCommitInfo(build) {
         const shortSha = build.commit ? build.commit.substring(0, 7) : 'unknown';
-        const message = build.message || 'No commit message';
-        const truncatedMessage = message.length > 60 ? message.substring(0, 57) + '...' : message;
-        return `   "${truncatedMessage}" (${shortSha})`;
+        const branch = SEMANTIC_COLORS.identifier(build.branch);
+        const age = this.formatAge(build.createdAt);
+        // Get author information
+        const author = build.createdBy?.name || build.createdBy?.email || 'Unknown';
+        // Calculate indentation to align with commit message
+        // Map each state to its proper indentation (icon + space + state text + space)
+        const indentMap = {
+            'PASSED': 9, // ✓ PASSED 
+            'FAILED': 9, // ✗ FAILED 
+            'RUNNING': 10, // ⟳ RUNNING 
+            'BLOCKED': 10, // ◼ BLOCKED 
+            'CANCELED': 11, // ⊘ CANCELED 
+            'SCHEDULED': 12, // ⏱ SCHEDULED 
+            'SKIPPED': 10, // ⊙ SKIPPED 
+        };
+        const indent = ' '.repeat(indentMap[build.state] || 9);
+        return `${indent}${author} • ${branch} • ${shortSha} • ${SEMANTIC_COLORS.dim(`Created ${age}`)}`;
     }
     formatAnnotationSummary(annotations) {
+        if (!annotations || annotations.length === 0) {
+            return '';
+        }
+        const lines = [];
+        const total = annotations.length;
+        // Header with count
         const counts = this.countAnnotationsByStyle(annotations);
-        const parts = [];
+        const countParts = [];
         if (counts.ERROR > 0)
-            parts.push(SEMANTIC_COLORS.error(`${counts.ERROR} error${counts.ERROR > 1 ? 's' : ''}`));
+            countParts.push(SEMANTIC_COLORS.error(`${counts.ERROR} error${counts.ERROR > 1 ? 's' : ''}`));
         if (counts.WARNING > 0)
-            parts.push(SEMANTIC_COLORS.warning(`${counts.WARNING} warning${counts.WARNING > 1 ? 's' : ''}`));
+            countParts.push(SEMANTIC_COLORS.warning(`${counts.WARNING} warning${counts.WARNING > 1 ? 's' : ''}`));
         if (counts.INFO > 0)
-            parts.push(SEMANTIC_COLORS.info(`${counts.INFO} info`));
+            countParts.push(SEMANTIC_COLORS.info(`${counts.INFO} info`));
         if (counts.SUCCESS > 0)
-            parts.push(SEMANTIC_COLORS.success(`${counts.SUCCESS} success`));
-        const total = annotations.length;
-        return `📝 ${SEMANTIC_COLORS.count(String(total))} annotation${total > 1 ? 's' : ''}: ${parts.join(', ')}`;
+            countParts.push(SEMANTIC_COLORS.success(`${counts.SUCCESS} success`));
+        lines.push(`${getAnnotationIcon('DEFAULT')} ${SEMANTIC_COLORS.count(String(total))} annotation${total > 1 ? 's' : ''}: ${countParts.join(', ')}`);
+        // List each annotation with style and context
+        const grouped = this.groupAnnotationsByStyle(annotations);
+        const styleOrder = ['ERROR', 'WARNING', 'INFO', 'SUCCESS'];
+        for (const style of styleOrder) {
+            if (grouped[style]) {
+                for (const annotation of grouped[style]) {
+                    const icon = this.getAnnotationIcon(style);
+                    const context = annotation.node.context || 'default';
+                    const styleColored = this.colorizeAnnotationStyle(style);
+                    lines.push(`   ${icon} ${styleColored}: ${context}`);
+                }
+            }
+        }
+        return lines.join('\n');
     }
-    formatAnnotationDetails(annotations, options) {
+    formatJobSummary(jobsData, buildState) {
+        const jobs = jobsData?.edges;
+        if (!jobs || jobs.length === 0) {
+            return '';
+        }
+        const lines = [];
+        const jobStats = this.getJobStats(jobs);
+        // Build summary parts based on job states
+        const countParts = [];
+        if (jobStats.failed > 0)
+            countParts.push(SEMANTIC_COLORS.error(`${jobStats.failed} failed`));
+        if (jobStats.passed > 0)
+            countParts.push(SEMANTIC_COLORS.success(`${jobStats.passed} passed`));
+        if (jobStats.running > 0)
+            countParts.push(SEMANTIC_COLORS.info(`${jobStats.running} running`));
+        if (jobStats.blocked > 0)
+            countParts.push(SEMANTIC_COLORS.warning(`${jobStats.blocked} blocked`));
+        // Don't show skipped jobs
+        if (jobStats.canceled > 0)
+            countParts.push(SEMANTIC_COLORS.muted(`${jobStats.canceled} canceled`));
+        // Use appropriate icon based on build state
+        const icon = buildState === 'FAILED' ? getStateIcon('FAILED') :
+            buildState === 'RUNNING' ? getStateIcon('RUNNING') :
+                buildState === 'PASSED' ? getStateIcon('PASSED') :
+                    buildState === 'BLOCKED' ? getStateIcon('BLOCKED') : '•';
+        // Check if we have partial data
+        const hasMorePages = jobsData?.pageInfo?.hasNextPage;
+        const totalCount = jobsData?.count;
+        if (hasMorePages) {
+            const showing = jobs.length;
+            const total = totalCount || `${showing}+`;
+            lines.push(`${icon} Showing ${SEMANTIC_COLORS.count(String(showing))} of ${SEMANTIC_COLORS.count(String(total))} steps: ${countParts.join(', ')}`);
+            lines.push(SEMANTIC_COLORS.warning('⚠️  Showing first 100 steps only (more available)'));
+            lines.push(SEMANTIC_COLORS.dim('  → Use --jobs to fetch all step data and see accurate statistics'));
+        }
+        else {
+            lines.push(`${icon} ${SEMANTIC_COLORS.count(String(jobStats.total))} step${jobStats.total > 1 ? 's' : ''}: ${countParts.join(', ')}`);
+        }
+        // For failed builds, show the specific failed job names
+        if (buildState === 'FAILED') {
+            const failedJobs = this.getFailedJobs(jobs);
+            const jobGroups = this.groupJobsByLabel(failedJobs);
+            // Show up to 3 failed job types
+            const displayGroups = jobGroups.slice(0, 3);
+            for (const group of displayGroups) {
+                const label = this.parseEmoji(group.label);
+                const icon = getStateIcon('FAILED');
+                // Get duration for display
+                const duration = group.count === 1 && group.jobs[0]?.node
+                    ? ` ${SEMANTIC_COLORS.dim(`- ran ${this.formatJobDuration(group.jobs[0].node)}`)}`
+                    : '';
+                if (group.parallelTotal > 0) {
+                    lines.push(`   ${icon} ${label} ${SEMANTIC_COLORS.dim(`(${group.stateCounts.failed || 0}/${group.parallelTotal} failed)`)}`);
+                }
+                else if (group.count > 1) {
+                    lines.push(`   ${icon} ${label} ${SEMANTIC_COLORS.dim(`(${group.stateCounts.failed || 0} failed)`)}`);
+                }
+                else {
+                    lines.push(`   ${icon} ${label}${duration}`);
+                }
+            }
+            if (jobGroups.length > 3) {
+                lines.push(`   ${SEMANTIC_COLORS.muted(`...and ${jobGroups.length - 3} more`)}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    formatAnnotationDetails(annotations) {
         const lines = [];
         // Group annotations by style
         const grouped = this.groupAnnotationsByStyle(annotations);
-        for (const [style, items] of Object.entries(grouped)) {
-            for (const annotation of items) {
-                const icon = this.getAnnotationIcon(style);
-                const context = annotation.node.context || 'default';
-                if (options?.annotationsFull) {
-                    // Full content
-                    lines.push(`${icon} ${style} [${context}]:`);
+        const styleOrder = ['ERROR', 'WARNING', 'INFO', 'SUCCESS'];
+        for (const style of styleOrder) {
+            if (grouped[style]) {
+                for (const annotation of grouped[style]) {
+                    const icon = this.getAnnotationIcon(style);
+                    const context = annotation.node.context || 'default';
+                    const styleColored = this.colorizeAnnotationStyle(style);
+                    // When showing annotation details, always show the body text
+                    lines.push(`${icon} ${styleColored}: ${context}`);
                     const body = htmlToText(annotation.node.body?.html || '', {
                         wordwrap: 80,
                         preserveNewlines: true
@@ -331,118 +517,123 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
                     lines.push(body.split('\n').map(l => `   ${l}`).join('\n'));
                     lines.push('');
                 }
-                else {
-                    // Summary only
-                    lines.push(`${icon} ${style} [${context}]`);
-                }
             }
         }
-        return lines.join('\n');
+        return lines.join('\n').trim();
     }
     formatJobDetails(jobs, options) {
         if (!jobs || jobs.length === 0) {
-            return 'No jobs found';
+            return 'No steps found';
         }
         const lines = [];
         const jobStats = this.getJobStats(jobs);
         // Summary line
         const parts = [];
         if (jobStats.passed > 0)
-            parts.push(`✅ ${jobStats.passed} passed`);
+            parts.push(`${getStateIcon('PASSED')} ${jobStats.passed} passed`);
         if (jobStats.failed > 0)
-            parts.push(`❌ ${jobStats.failed} failed`);
+            parts.push(`${getStateIcon('FAILED')} ${jobStats.failed} failed`);
         if (jobStats.running > 0)
-            parts.push(`🔄 ${jobStats.running} running`);
+            parts.push(`${getStateIcon('RUNNING')} ${jobStats.running} running`);
         if (jobStats.blocked > 0)
-            parts.push(`⏸️ ${jobStats.blocked} blocked`);
-        if (jobStats.skipped > 0)
-            parts.push(`⏭️ ${jobStats.skipped} skipped`);
-        lines.push(`Jobs: ${parts.join('  ')}`);
+            parts.push(`${getStateIcon('BLOCKED')} ${jobStats.blocked} blocked`);
+        // Don't show skipped jobs in summary
+        lines.push(`Steps: ${parts.join('  ')}`);
         lines.push('');
         // Filter jobs based on options
         let filteredJobs = jobs;
         if (options?.failed) {
             filteredJobs = this.getFailedJobs(jobs);
         }
-        // Group jobs by state
+        // Group jobs by state first
         const grouped = this.groupJobsByState(filteredJobs);
         for (const [state, stateJobs] of Object.entries(grouped)) {
             if (stateJobs.length === 0)
                 continue;
             const icon = this.getJobStateIcon(state);
             const stateColored = this.colorizeJobState(state);
+            // Collapse parallel jobs with same label
+            const collapsedGroups = this.collapseParallelJobs(stateJobs);
             lines.push(`${icon} ${stateColored} (${SEMANTIC_COLORS.count(String(stateJobs.length))}):`);
-            for (const job of stateJobs) {
-                const label = this.parseEmoji(job.node.label);
-                const duration = this.formatJobDuration(job.node);
-                const exitCode = job.node.exitStatus ? `, exit ${job.node.exitStatus}` : '';
-                lines.push(`  ${label} (${duration}${exitCode})`);
-                if (options?.full && job.node.agent) {
-                    lines.push(`    ${SEMANTIC_COLORS.dim(`Agent: ${job.node.agent.name || job.node.agent.hostname}`)}`);
+            for (const group of collapsedGroups) {
+                if (group.isParallelGroup && group.jobs.length > 1) {
+                    // Collapsed parallel group display
+                    const label = this.parseEmoji(group.label);
+                    const total = group.parallelTotal || group.jobs.length;
+                    const passedCount = group.jobs.filter(j => this.isJobPassed(j.node)).length;
+                    const failedCount = group.jobs.filter(j => this.isJobFailed(j.node)).length;
+                    // Show summary line for parallel group
+                    if (failedCount > 0) {
+                        // If there are failures, show breakdown
+                        // Apply state color to label
+                        const coloredLabel = state === 'Failed' ? SEMANTIC_COLORS.error(label) :
+                            state === 'Passed' ? SEMANTIC_COLORS.success(label) :
+                                state === 'Running' ? SEMANTIC_COLORS.info(label) :
+                                    state === 'Blocked' ? SEMANTIC_COLORS.warning(label) : label;
+                        lines.push(`  ${coloredLabel} ${SEMANTIC_COLORS.dim(`(${passedCount}/${total} passed, ${failedCount} failed)`)}`);
+                        // Show failed steps individually
+                        const failedJobs = group.jobs.filter(j => this.isJobFailed(j.node));
+                        for (const job of failedJobs) {
+                            const duration = this.formatJobDuration(job.node);
+                            const parallelInfo = job.node.parallelGroupIndex !== undefined
+                                ? ` ${SEMANTIC_COLORS.dim(`[Parallel: ${job.node.parallelGroupIndex + 1}/${job.node.parallelGroupTotal}]`)}`
+                                : '';
+                            lines.push(`    ${SEMANTIC_COLORS.error('↳ Failed')}: ${SEMANTIC_COLORS.dim(duration)}${parallelInfo}`);
+                        }
+                    }
+                    else {
+                        // All passed/running/blocked - just show summary
+                        const avgDuration = this.calculateAverageDuration(group.jobs);
+                        // Apply state color to label
+                        const coloredLabel = state === 'Passed' ? SEMANTIC_COLORS.success(label) :
+                            state === 'Failed' ? SEMANTIC_COLORS.error(label) :
+                                state === 'Running' ? SEMANTIC_COLORS.info(label) :
+                                    state === 'Blocked' ? SEMANTIC_COLORS.warning(label) : label;
+                        lines.push(`  ${coloredLabel} ${SEMANTIC_COLORS.dim(`(${total} parallel steps, avg: ${avgDuration})`)}`);
+                    }
+                }
+                else {
+                    // Single job or non-parallel group - display as before
+                    const job = group.jobs[0];
+                    const label = this.parseEmoji(job.node.label);
+                    const duration = this.formatJobDuration(job.node);
+                    // Apply state color to label
+                    const coloredLabel = state === 'Passed' ? SEMANTIC_COLORS.success(label) :
+                        state === 'Failed' ? SEMANTIC_COLORS.error(label) :
+                            state === 'Running' ? SEMANTIC_COLORS.info(label) :
+                                state === 'Blocked' ? SEMANTIC_COLORS.warning(label) : label;
+                    // Add parallel info inline if present
+                    const parallelInfo = (job.node.parallelGroupIndex !== undefined && job.node.parallelGroupTotal)
+                        ? ` ${SEMANTIC_COLORS.dim(`[Parallel: ${job.node.parallelGroupIndex + 1}/${job.node.parallelGroupTotal}]`)}`
+                        : '';
+                    // Basic step line with optional parallel info
+                    lines.push(`  ${coloredLabel} ${SEMANTIC_COLORS.dim(`(${duration})`)}${parallelInfo}`);
+                    // Show additional details if --jobs or --full and single step
+                    if ((options?.jobs || options?.full) && !group.isParallelGroup) {
+                        // Retry info
+                        if (job.node.retried) {
+                            lines.push(`    ${SEMANTIC_COLORS.warning(`${getProgressIcon('RETRY')} Retried`)}`);
+                        }
+                    }
                 }
             }
             lines.push('');
         }
         return lines.join('\n').trim();
     }
-    formatFailedJobsSummary(failedJobs) {
-        const lines = [];
-        // Group identical jobs by label
-        const jobGroups = this.groupJobsByLabel(failedJobs);
-        // Show first 10 unique job types
-        const displayGroups = jobGroups.slice(0, 10);
-        for (const group of displayGroups) {
-            const label = this.parseEmoji(group.label);
-            if (group.count === 1) {
-                const duration = this.formatJobDuration(group.jobs[0].node);
-                lines.push(`   ${SEMANTIC_COLORS.error('Failed')}: ${label} - ran ${duration}`);
-            }
-            else {
-                // Multiple jobs with same label - show detailed breakdown
-                const statusParts = [];
-                if (group.stateCounts.failed > 0) {
-                    statusParts.push(`${group.stateCounts.failed} failed`);
-                }
-                if (group.stateCounts.broken > 0) {
-                    statusParts.push(`${group.stateCounts.broken} broken`);
-                }
-                if (group.stateCounts.notStarted > 0) {
-                    statusParts.push(`${group.stateCounts.notStarted} not started`);
-                }
-                if (group.stateCounts.passed > 0) {
-                    statusParts.push(`${group.stateCounts.passed} passed`);
-                }
-                if (group.stateCounts.other > 0) {
-                    statusParts.push(`${group.stateCounts.other} other`);
-                }
-                // Add exit codes if available
-                if (group.exitCodes.length > 0) {
-                    const exitCodeStr = group.exitCodes.length === 1
-                        ? `exit ${group.exitCodes[0]}`
-                        : `exits: ${group.exitCodes.join(', ')}`;
-                    statusParts.push(exitCodeStr);
-                }
-                const statusInfo = statusParts.join(', ') || 'various states';
-                lines.push(`   ${SEMANTIC_COLORS.error('Failed')}: ${label} (${SEMANTIC_COLORS.count(String(group.count))} jobs: ${statusInfo})`);
-            }
-        }
-        // Add summary if there are more job types
-        const remaining = jobGroups.length - displayGroups.length;
-        if (remaining > 0) {
-            lines.push(`   ${SEMANTIC_COLORS.muted(`...and ${remaining} more job types`)}`);
-        }
-        return lines.join('\n');
-    }
     groupJobsByLabel(jobs) {
         const groups = new Map();
         for (const job of jobs) {
-            const label = job.node.label || 'Unnamed job';
-            if (!groups.has(label)) {
-                groups.set(label, {
-                    label,
+            const fullLabel = job.node.label || 'Unnamed job';
+            // Strip parallel job index from label for grouping
+            // e.g., "deposit_and_filing_schedule_calculator rspec (1/22)" -> "deposit_and_filing_schedule_calculator rspec"
+            const baseLabel = fullLabel.replace(/\s*\(\d+\/\d+\)\s*$/, '').trim();
+            if (!groups.has(baseLabel)) {
+                groups.set(baseLabel, {
+                    label: baseLabel,
                     count: 0,
                     jobs: [],
-                    exitCodes: new Set(),
+                    parallelTotal: 0,
                     stateCounts: {
                         failed: 0,
                         broken: 0,
@@ -452,18 +643,41 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
                     }
                 });
             }
-            const group = groups.get(label);
+            const group = groups.get(baseLabel);
             group.count++;
             group.jobs.push(job);
-            // Track exit codes
-            if (job.node.exitStatus !== null && job.node.exitStatus !== undefined) {
-                group.exitCodes.add(job.node.exitStatus);
+            // Track the maximum parallel total for this job group
+            if (job.node.parallelGroupTotal && job.node.parallelGroupTotal > group.parallelTotal) {
+                group.parallelTotal = job.node.parallelGroupTotal;
             }
             // Count by state
             const state = job.node.state?.toUpperCase();
-            if (!job.node.startedAt) {
+            // Use exit status as source of truth when available
+            // Note: exitStatus comes as a string from Buildkite API
+            if (job.node.exitStatus !== null && job.node.exitStatus !== undefined) {
+                const exitCode = parseInt(job.node.exitStatus, 10);
+                if (exitCode === 0) {
+                    group.stateCounts.passed++;
+                }
+                else {
+                    group.stateCounts.failed++;
+                }
+            }
+            else if (!job.node.startedAt) {
                 group.stateCounts.notStarted++;
             }
+            else if (state === 'FINISHED' || state === 'COMPLETED') {
+                // For finished jobs without exit status, check passed field
+                if (job.node.passed === true) {
+                    group.stateCounts.passed++;
+                }
+                else if (job.node.passed === false) {
+                    group.stateCounts.failed++;
+                }
+                else {
+                    group.stateCounts.other++;
+                }
+            }
             else if (state === 'FAILED') {
                 group.stateCounts.failed++;
             }
@@ -479,7 +693,6 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
         }
         // Convert to array and sort by count (most failures first)
         return Array.from(groups.values())
-            .map(g => ({ ...g, exitCodes: Array.from(g.exitCodes) }))
             .sort((a, b) => b.count - a.count);
     }
     formatDuration(build) {
@@ -528,37 +741,35 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
         }
     }
     getStatusIcon(state) {
-        const icons = {
-            'PASSED': '✅',
-            'FAILED': '❌',
-            'RUNNING': '🔄',
-            'BLOCKED': '⏸️',
-            'CANCELED': '🚫',
-            'SCHEDULED': '📅',
-            'SKIPPED': '⏭️'
-        };
-        return icons[state] || '❓';
+        return getStateIcon(state);
     }
     getJobStateIcon(state) {
-        const icons = {
-            'passed': '✅',
-            'failed': '❌',
-            'running': '🔄',
-            'blocked': '⏸️',
-            'canceled': '🚫',
-            'scheduled': '📅',
-            'skipped': '⏭️'
-        };
-        return icons[state.toLowerCase()] || '❓';
+        return getStateIcon(state);
     }
     getAnnotationIcon(style) {
-        const icons = {
-            'ERROR': '❌',
-            'WARNING': '⚠️',
-            'INFO': 'ℹ️',
-            'SUCCESS': '✅'
-        };
-        return icons[style.toUpperCase()] || '📝';
+        return getAnnotationIcon(style);
+    }
+    colorizeAnnotationStyle(style) {
+        switch (style.toUpperCase()) {
+            case 'ERROR':
+                return SEMANTIC_COLORS.error(style.toLowerCase());
+            case 'WARNING':
+                return SEMANTIC_COLORS.warning(style.toLowerCase());
+            case 'INFO':
+                return SEMANTIC_COLORS.info(style.toLowerCase());
+            case 'SUCCESS':
+                return SEMANTIC_COLORS.success(style.toLowerCase());
+            default:
+                return style.toLowerCase();
+        }
+    }
+    colorizeStatusIcon(icon, state) {
+        const upperState = state.toUpperCase();
+        const theme = BUILD_STATUS_THEME[upperState];
+        if (!theme) {
+            return SEMANTIC_COLORS.muted(icon);
+        }
+        return theme.color(icon);
     }
     getJobStats(jobs) {
         const stats = {
@@ -568,6 +779,7 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
             running: 0,
             blocked: 0,
             skipped: 0,
+            canceled: 0,
             queued: 0,
             completed: 0
         };
@@ -575,13 +787,18 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
             return stats;
         for (const job of jobs) {
             const state = job.node.state?.toUpperCase() || '';
-            if (state === 'PASSED' || (job.node.passed === true && state !== 'BROKEN')) {
-                stats.passed++;
-                stats.completed++;
-            }
-            else if (state === 'FAILED' || state === 'BROKEN' || (job.node.exitStatus && job.node.exitStatus !== 0) || job.node.passed === false) {
-                stats.failed++;
-                stats.completed++;
+            // If we have an exit status, use that as the source of truth
+            // Note: exitStatus comes as a string from Buildkite API
+            if (job.node.exitStatus !== null && job.node.exitStatus !== undefined) {
+                const exitCode = parseInt(job.node.exitStatus, 10);
+                if (exitCode === 0) {
+                    stats.passed++;
+                    stats.completed++;
+                }
+                else {
+                    stats.failed++;
+                    stats.completed++;
+                }
             }
             else if (state === 'RUNNING') {
                 stats.running++;
@@ -589,13 +806,37 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
             else if (state === 'BLOCKED') {
                 stats.blocked++;
             }
-            else if (state === 'SKIPPED' || state === 'CANCELED') {
+            else if (state === 'CANCELED' || state === 'CANCELLED') {
+                stats.canceled++;
+                stats.completed++;
+            }
+            else if (state === 'SKIPPED' || state === 'BROKEN') {
+                // BROKEN jobs are functionally skipped - they don't run due to conditions not matching
                 stats.skipped++;
                 stats.completed++;
             }
             else if (state === 'SCHEDULED' || state === 'ASSIGNED') {
                 stats.queued++;
             }
+            else if (state === 'FINISHED' || state === 'COMPLETED') {
+                // For finished jobs without exit status, check passed field
+                if (job.node.passed === true) {
+                    stats.passed++;
+                    stats.completed++;
+                }
+                else if (job.node.passed === false) {
+                    stats.failed++;
+                    stats.completed++;
+                }
+            }
+            else if (state === 'PASSED' || job.node.passed === true) {
+                stats.passed++;
+                stats.completed++;
+            }
+            else if (state === 'FAILED' || job.node.passed === false) {
+                stats.failed++;
+                stats.completed++;
+            }
         }
         return stats;
     }
@@ -604,7 +845,22 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
             return [];
         return jobs.filter(job => {
             const state = job.node.state?.toUpperCase();
-            return state === 'FAILED' || state === 'BROKEN' || (job.node.exitStatus && job.node.exitStatus !== 0) || job.node.passed === false;
+            // BROKEN jobs are skipped/not run, not failed
+            if (state === 'BROKEN' || state === 'SKIPPED') {
+                return false;
+            }
+            // If we have an exit status, use that as the source of truth
+            // Note: exitStatus comes as a string from Buildkite API
+            if (job.node.exitStatus !== null && job.node.exitStatus !== undefined) {
+                const exitCode = parseInt(job.node.exitStatus, 10);
+                return exitCode !== 0;
+            }
+            // For FINISHED jobs, check the passed field
+            if (state === 'FINISHED') {
+                return job.node.passed === false;
+            }
+            // Otherwise check if explicitly failed
+            return state === 'FAILED';
         });
     }
     getRunningJobs(jobs) {
@@ -622,18 +878,23 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
             'Failed': [],
             'Passed': [],
             'Running': [],
-            'Blocked': [],
-            'Skipped': []
+            'Blocked': []
+            // Don't include Skipped - we don't display them
         };
         if (!jobs)
             return grouped;
         for (const job of jobs) {
             const state = job.node.state?.toUpperCase() || '';
-            if (state === 'FAILED' || state === 'BROKEN' || (job.node.exitStatus && job.node.exitStatus !== 0) || job.node.passed === false) {
-                grouped['Failed'].push(job);
-            }
-            else if (state === 'PASSED' || (job.node.passed === true && state !== 'BROKEN')) {
-                grouped['Passed'].push(job);
+            // If we have an exit status, use that as the source of truth
+            // Note: exitStatus comes as a string from Buildkite API
+            if (job.node.exitStatus !== null && job.node.exitStatus !== undefined) {
+                const exitCode = parseInt(job.node.exitStatus, 10);
+                if (exitCode === 0) {
+                    grouped['Passed'].push(job);
+                }
+                else {
+                    grouped['Failed'].push(job);
+                }
             }
             else if (state === 'RUNNING') {
                 grouped['Running'].push(job);
@@ -641,12 +902,104 @@ export class PlainTextFormatter extends BaseBuildDetailFormatter {
             else if (state === 'BLOCKED') {
                 grouped['Blocked'].push(job);
             }
-            else if (state === 'SKIPPED' || state === 'CANCELED') {
-                grouped['Skipped'].push(job);
+            else if (state === 'SKIPPED' || state === 'CANCELED' || state === 'BROKEN') {
+                // Don't display skipped/broken/canceled jobs - they're not shown in Buildkite UI
+                // Skip these entirely
+            }
+            else if (state === 'FINISHED' || state === 'COMPLETED') {
+                // For finished jobs without exit status, check passed field
+                if (job.node.passed === true) {
+                    grouped['Passed'].push(job);
+                }
+                else if (job.node.passed === false) {
+                    grouped['Failed'].push(job);
+                }
+            }
+            else if (state === 'PASSED' || job.node.passed === true) {
+                grouped['Passed'].push(job);
+            }
+            else if (state === 'FAILED') {
+                grouped['Failed'].push(job);
             }
         }
         return grouped;
     }
+    collapseParallelJobs(jobs) {
+        const groups = new Map();
+        // Group jobs by label
+        for (const job of jobs) {
+            const label = job.node.label || 'Unnamed';
+            if (!groups.has(label)) {
+                groups.set(label, []);
+            }
+            groups.get(label).push(job);
+        }
+        // Convert to array and determine if each group is a parallel group
+        const result = [];
+        for (const [label, groupJobs] of groups.entries()) {
+            // Check if this is a parallel group (multiple jobs with same label and parallel info)
+            const hasParallelInfo = groupJobs.some(j => j.node.parallelGroupIndex !== undefined && j.node.parallelGroupTotal !== undefined);
+            const isParallelGroup = hasParallelInfo && groupJobs.length > 1;
+            // Get the total from the first job if available
+            const parallelTotal = groupJobs[0]?.node?.parallelGroupTotal;
+            result.push({
+                label,
+                jobs: groupJobs,
+                isParallelGroup,
+                parallelTotal
+            });
+        }
+        return result;
+    }
+    isJobPassed(job) {
+        const state = job.state?.toUpperCase();
+        if (job.exitStatus !== null && job.exitStatus !== undefined) {
+            return parseInt(job.exitStatus, 10) === 0;
+        }
+        if (state === 'PASSED')
+            return true;
+        if (state === 'FINISHED' || state === 'COMPLETED') {
+            return job.passed === true;
+        }
+        return job.passed === true;
+    }
+    isJobFailed(job) {
+        const state = job.state?.toUpperCase();
+        if (job.exitStatus !== null && job.exitStatus !== undefined) {
+            return parseInt(job.exitStatus, 10) !== 0;
+        }
+        if (state === 'FAILED')
+            return true;
+        if (state === 'FINISHED' || state === 'COMPLETED') {
+            return job.passed === false;
+        }
+        return false;
+    }
+    calculateAverageDuration(jobs) {
+        const durationsMs = jobs
+            .filter(j => j.node.startedAt && j.node.finishedAt)
+            .map(j => {
+            const start = new Date(j.node.startedAt).getTime();
+            const end = new Date(j.node.finishedAt).getTime();
+            return end - start;
+        });
+        if (durationsMs.length === 0) {
+            return 'unknown';
+        }
+        const avgMs = durationsMs.reduce((a, b) => a + b, 0) / durationsMs.length;
+        const avgSeconds = Math.floor(avgMs / 1000);
+        if (avgSeconds < 60) {
+            return `${avgSeconds}s`;
+        }
+        const minutes = Math.floor(avgSeconds / 60);
+        const seconds = avgSeconds % 60;
+        if (minutes < 60) {
+            return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+        }
+        const hours = Math.floor(minutes / 60);
+        const remainingMinutes = minutes % 60;
+        return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+    }
     countAnnotationsByStyle(annotations) {
         const counts = {
             ERROR: 0,