@vizzly-testing/cli 0.35.1 → 0.35.3-beta.0

package/dist/commands/context.js

@@ -8,6 +8,7 @@ import { resolveContextSource as defaultResolveContextSource } from '../context/
 import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
 import * as defaultOutput from '../utils/output.js';
 import { readSession as defaultReadSession } from '../utils/session.js';
+import { normalizeBuildContext } from '../utils/visual-context-normalizers.js';
 function buildAuthErrorMessage() {
   return 'Authentication required. Use --token, set VIZZLY_TOKEN, run "vizzly login", or link a project.';
 }
@@ -76,6 +77,24 @@ function createClient(config, createApiClient) {
     command: 'context'
   });
 }
+
+/**
+ * Attach the provider that produced a context payload.
+ *
+ * Context endpoints return API-owned evidence, while source selection belongs
+ * to the CLI. Keeping both in one payload prevents follow-up agent commands
+ * from silently crossing between cloud and local evidence.
+ *
+ * @param {Object} context - Context payload returned by a provider.
+ * @param {string} source - Provider source selected by the CLI.
+ * @returns {Object} Context payload with explicit source provenance.
+ */
+function attachContextSource(context, source) {
+  return {
+    ...context,
+    source: context?.source || source
+  };
+}
 async function loadContextConfig(globalOptions, options, deps) {
   let {
     loadConfig = defaultLoadConfig,
@@ -108,20 +127,20 @@ function createCloudContextProvider(config, deps = {}) {
   let client = createClient(config, createApiClient);
   return {
     source: 'cloud',
-    async getBuildContext(buildId) {
-      return await getBuildContext(client, buildId);
+    async getBuildContext(buildId, query) {
+      return attachContextSource(await getBuildContext(client, buildId, query), 'cloud');
     },
     async getComparisonContext(comparisonId, query) {
-      return await getComparisonContext(client, comparisonId, query);
+      return attachContextSource(await getComparisonContext(client, comparisonId, query), 'cloud');
     },
     async getScreenshotContext(screenshotName, query) {
-      return await getScreenshotContext(client, screenshotName, query);
+      return attachContextSource(await getScreenshotContext(client, screenshotName, query), 'cloud');
     },
     async getSimilarFingerprintContext(fingerprintHash, query) {
-      return await getSimilarFingerprintContext(client, fingerprintHash, query);
+      return attachContextSource(await getSimilarFingerprintContext(client, fingerprintHash, query), 'cloud');
     },
     async getReviewQueueContext(query) {
-      return await getReviewQueueContext(client, query);
+      return attachContextSource(await getReviewQueueContext(client, query), 'cloud');
     }
   };
 }
@@ -235,139 +254,286 @@ function getComparisonDiffPercentage(comparison = {}) {
 function getComparisonFingerprint(comparison = {}) {
   return comparison.diff?.fingerprint_hash || comparison.analysis?.fingerprint_hash || null;
 }
-function getComparisonDiffImageUrl(comparison = {}) {
-  return comparison.diff?.image_url || comparison.analysis?.diff_image_url || null;
-}
-function getComparisonRegionCount(comparison = {}) {
-  let regions = comparison.diff?.regions || comparison.analysis?.diff_regions;
-  return Array.isArray(regions) ? regions.length : 0;
-}
-function getComparisonScreenshot(comparison = {}) {
-  return comparison.screenshot || {};
-}
-function getComparisonBaseline(comparison = {}) {
-  return comparison.baseline || comparison.screenshot?.baseline || {};
-}
-function buildCompactDiff(comparison = {}, includeDiffs = false) {
-  let diff = comparison.diff || comparison.analysis || {};
-  let compact = {
-    percentage: getComparisonDiffPercentage(comparison),
-    changed_pixels: diff.changed_pixels ?? comparison.changed_pixels ?? null,
-    total_pixels: diff.total_pixels ?? comparison.total_pixels ?? null,
-    threshold: diff.threshold ?? comparison.threshold ?? null,
-    fingerprint_hash: getComparisonFingerprint(comparison),
-    region_count: getComparisonRegionCount(comparison),
-    image_url: getComparisonDiffImageUrl(comparison)
-  };
-  if (includeDiffs) {
-    compact.regions = diff.regions || diff.diff_regions || [];
-    compact.cluster_metadata = diff.cluster_metadata || null;
-    compact.ssim_score = diff.ssim_score ?? null;
-    compact.gmsd_score = diff.gmsd_score ?? null;
-    compact.diff_lines = diff.diff_lines || [];
+
+/**
+ * Decide whether a comparison belongs in the agent handoff.
+ *
+ * Explicit API review state wins because an already-reviewed visual change is
+ * not actionable. Legacy result fallback keeps older flat responses useful
+ * only when the server did not supply that review fact.
+ *
+ * @param {Object} comparison - Normalized comparison record.
+ * @returns {boolean} Whether the record is actionable evidence.
+ */
+function isEvidenceCandidate(comparison = {}) {
+  if (comparison.needs_review != null) {
+    return comparison.needs_review === true;
   }
-  return compact;
+  return ['changed', 'new', 'failed', 'error'].includes(comparison.result);
 }
-function buildCompactComparison(comparison = {}, {
-  includeDiffs = false
-} = {}) {
-  let screenshot = getComparisonScreenshot(comparison);
-  let baseline = getComparisonBaseline(comparison);
+
+/**
+ * Keep the group facts needed to understand one comparison in isolation.
+ *
+ * Repeating this small server-owned summary on each record avoids returning
+ * the full, potentially unbounded group tree in compact agent output.
+ *
+ * @param {Object} group - Normalized screenshot group.
+ * @returns {Object} Compact API-backed aggregate facts for the group.
+ */
+function buildEvidenceGroup(group = {}) {
+  let aggregate = group.aggregate_status || {};
   return {
-    id: comparison.id || null,
-    name: getComparisonName(comparison),
-    result: getComparisonDisplayState(comparison),
-    approval_status: comparison.approval_status || null,
-    needs_review: Boolean(comparison.needs_review),
-    is_flaky: Boolean(comparison.is_flaky),
-    screenshot: {
-      id: screenshot.id || null,
-      url: screenshot.url || screenshot.original_url || null
-    },
-    baseline: {
-      id: baseline.id || null,
-      build_id: baseline.build_id || null,
-      url: baseline.url || baseline.original_url || null
-    },
-    diff: buildCompactDiff(comparison, includeDiffs)
+    name: group.name || null,
+    variant_count: group.variant_count ?? null,
+    needs_review_count: aggregate.needs_review_count ?? null,
+    failed_count: aggregate.failed_count ?? null,
+    max_diff_percentage: aggregate.max_diff_percentage ?? null
   };
 }
-function summarizeComparisons(comparisons = []) {
+
+/**
+ * Shape one normalized comparison for the bounded evidence queue.
+ *
+ * The projection keeps visual result, review state, render assets, and
+ * Honeydiff facts together so an agent can reason about a diff without
+ * joining separate collections client-side.
+ *
+ * @param {Object} comparison - Normalized comparison record.
+ * @param {Object} group - Normalized group containing the comparison.
+ * @returns {Object} One self-contained comparison evidence record.
+ */
+function buildComparisonEvidence(comparison = {}, group = {}) {
   return {
-    total: comparisons.length,
-    changed: comparisons.filter(isChangedComparison).length,
-    new: comparisons.filter(isNewComparison).length,
-    needs_review: comparisons.filter(comparison => comparison.needs_review).length
+    kind: 'comparison',
+    id: comparison.id,
+    name: comparison.name,
+    result: comparison.result,
+    status: comparison.status,
+    review_state: comparison.review_state,
+    visual_review: comparison.visual_review,
+    approval_status: comparison.approval_status,
+    needs_review: comparison.needs_review,
+    is_flaky: comparison.is_flaky,
+    group: buildEvidenceGroup(group),
+    screenshot: comparison.screenshot,
+    baseline: comparison.baseline,
+    diff: comparison.diff
   };
 }
-function buildAgentNextActions(context = {}, comparisonSummary = {}) {
-  if (context.status?.needs_review) {
-    return ['Inspect the changed and new comparisons before editing related UI.', 'Use approved baselines as the expected visual behavior.', 'Leave approval decisions to human reviewers.'];
-  }
-  if (comparisonSummary.total > 0) {
-    return ['Use the approved baseline and reviewed screenshots as current visual truth.', 'Prefer targeted edits that preserve identical comparisons.'];
-  }
-  return ['No comparisons were returned for this build context.', 'Open the build URL for more detail if this is unexpected.'];
-}
-function formatAgentStatus(status = {}) {
+
+/**
+ * Represent a capture failure without pretending it is a comparison.
+ *
+ * Failed screenshots have useful render evidence but no comparison ID. The
+ * explicit kind and null ID prevent suggested commands from sending a
+ * screenshot identifier to the comparison endpoint.
+ *
+ * @param {Object} capture - Normalized failed screenshot capture.
+ * @returns {Object} One failed-capture evidence record.
+ */
+function buildFailedCaptureEvidence(capture = {}) {
   return {
-    needs_review: Boolean(status.needs_review),
-    reasons: status.reasons || [],
-    pending_comparisons: status.pending_comparisons || 0,
-    unresolved_comments: status.unresolved_comments || 0
+    ...buildComparisonEvidence(capture, {
+      name: capture.name
+    }),
+    kind: 'failed_capture',
+    id: null,
+    error_message: capture.error_message
   };
 }
-function formatAgentSummary(context = {}, comparisons = []) {
-  return {
-    comparisons: context.summary?.comparisons || summarizeComparisons(comparisons),
-    review: context.summary?.review || {},
-    comments: context.summary?.comments || {
-      build: getBuildCommentsCount(context),
-      screenshot: getScreenshotCommentsCount(context)
+
+/**
+ * Read actionable variants without overriding a server-reviewed group.
+ *
+ * A false aggregate is authoritative even when a partial variant payload
+ * appears pending, which prevents the client from reopening completed work.
+ *
+ * @param {Object} group - Normalized screenshot group.
+ * @returns {Object[]} Actionable variants in API order.
+ */
+function getGroupEvidence(group = {}) {
+  if (group.aggregate_status?.needs_review === false) {
+    return [];
+  }
+  return (group.variants || []).filter(isEvidenceCandidate);
+}
+
+/**
+ * Interleave actionable variants across groups in their original API order.
+ *
+ * Taking one variant per group before taking second variants preserves useful
+ * breadth when the final handoff is capped and one screenshot has many device
+ * or browser variants.
+ *
+ * @param {Object[]} groups - Normalized screenshot groups.
+ * @returns {Object[]} Self-contained evidence records in breadth-first order.
+ */
+function selectBreadthFirstEvidence(groups = []) {
+  let candidatesByGroup = groups.map(getGroupEvidence);
+  let evidence = [];
+  let variantIndex = 0;
+  let remaining = candidatesByGroup.some(candidates => candidates.length > 0);
+  while (remaining) {
+    remaining = false;
+    for (let groupIndex = 0; groupIndex < groups.length; groupIndex += 1) {
+      let comparison = candidatesByGroup[groupIndex][variantIndex];
+      if (comparison) {
+        evidence.push(buildComparisonEvidence(comparison, groups[groupIndex]));
+        remaining = true;
+      }
     }
-  };
+    variantIndex += 1;
+  }
+  return evidence;
 }
+
+/**
+ * Quote a value only when a suggested command needs shell protection.
+ *
+ * Suggested commands are meant to be executable, so names with whitespace or
+ * apostrophes must survive copy and paste without changing their value.
+ *
+ * @param {unknown} value - CLI argument value.
+ * @returns {string} A shell-safe argument for the displayed command.
+ */
+function quoteCommandArgument(value) {
+  let stringValue = String(value);
+  if (/^[A-Za-z0-9._:/-]+$/.test(stringValue)) {
+    return stringValue;
+  }
+  return `'${stringValue.replaceAll("'", `'\\''`)}'`;
+}
+
+/**
+ * Recognize both local source labels emitted across supported context shapes.
+ *
+ * @param {Object} context - Normalized context response.
+ * @returns {boolean} Whether follow-up commands must stay in local mode.
+ */
+function isLocalContext(context = {}) {
+  return ['local', 'local_workspace'].includes(context.source);
+}
+
+/**
+ * Keep executable suggestions on the source that produced their evidence.
+ *
+ * Mixed workspaces can contain both a cloud run session and persisted local
+ * TDD results. Pinning either source prevents a follow-up command from
+ * silently crossing that boundary and describing a different build.
+ *
+ * @param {string} command - Base CLI command.
+ * @param {Object} context - Context that produced the command.
+ * @returns {string} Command pinned to its originating source.
+ */
+function appendContextSource(command, context = {}) {
+  let source = isLocalContext(context) ? 'local' : 'cloud';
+  return `${command} --source ${source}`;
+}
+
+/**
+ * Build concrete drill-down paths from the evidence actually returned.
+ *
+ * Executable commands replace generic client-authored advice. They let an
+ * agent ask the API for deeper comparison, history, or raw diff context, and
+ * only suggest the full build when the bounded queue omitted records.
+ *
+ * @param {Object} context - Normalized build context.
+ * @param {Object[]} evidence - Evidence included in the compact handoff.
+ * @param {boolean} truncated - Whether additional evidence was omitted.
+ * @returns {{label: string, command: string}[]} Suggested CLI commands.
+ */
+function buildSuggestedCommands(context = {}, evidence = [], truncated = false) {
+  let commands = [];
+  let firstComparison = evidence.find(item => item.kind === 'comparison' && item.id);
+  let firstNamedEvidence = evidence.find(item => item.name);
+  let buildTarget = isLocalContext(context) ? 'current' : context.build?.id || null;
+  if (firstComparison?.id) {
+    commands.push({
+      label: 'Inspect comparison context',
+      command: appendContextSource(`vizzly --json context comparison ${quoteCommandArgument(firstComparison.id)}`, context)
+    });
+  }
+  if (firstNamedEvidence?.name) {
+    commands.push({
+      label: 'Inspect screenshot history',
+      command: appendContextSource(`vizzly --json context screenshot ${quoteCommandArgument(firstNamedEvidence.name)}`, context)
+    });
+  }
+  if (buildTarget && evidence.length > 0) {
+    commands.push({
+      label: 'Load raw diff diagnostics',
+      command: appendContextSource(`vizzly --json context build ${quoteCommandArgument(buildTarget)} --agent --include diffs`, context)
+    });
+  }
+  if (buildTarget && truncated) {
+    commands.push({
+      label: 'Load full build context',
+      command: appendContextSource(`vizzly --json context build ${quoteCommandArgument(buildTarget)} --agent --full`, context)
+    });
+  }
+  return commands;
+}
+
+/**
+ * Create the compact agent presentation without rewriting API truth.
+ *
+ * Status, summaries, review facts, assets, and Honeydiff values pass through
+ * normalization from the server. The client owns only the bounded selection,
+ * truthful truncation facts, explicit includes, and follow-up commands.
+ *
+ * @param {Object} context - Raw build context returned by the provider.
+ * @param {Object} options - Compact presentation options.
+ * @param {string|null} [options.source] - Resolved source fallback.
+ * @param {string[]} [options.include] - Explicit detail collections.
+ * @param {number} [options.evidenceLimit] - Maximum evidence record count.
+ * @returns {Object} Bounded agent build context.
+ */
 function buildAgentBuildPayload(context, {
   source = null,
   include = [],
   evidenceLimit = 10
 } = {}) {
-  let comparisons = context.comparisons || [];
   let includeSet = new Set(include);
   let includeDiffs = includeSet.has('diffs');
-  let changed = comparisons.filter(isChangedComparison);
-  let fresh = comparisons.filter(isNewComparison);
-  let evidence = [...changed, ...fresh].slice(0, evidenceLimit).map(comparison => buildCompactComparison(comparison, {
+  let normalized = normalizeBuildContext(context, {
     includeDiffs
-  }));
-  let comparisonSummary = summarizeComparisons(comparisons);
+  });
+  let candidates = [...normalized.failed_captures.map(buildFailedCaptureEvidence), ...selectBreadthFirstEvidence(normalized.groups)];
+  let evidence = candidates.slice(0, evidenceLimit);
+  let evidenceTruncated = candidates.length > evidence.length;
   let payload = {
     resource: 'build_agent_context',
-    source: context.source || source || 'cloud',
-    scope: context.scope || null,
+    source: normalized.source || source,
+    review_flow: normalized.review_flow,
+    scope: normalized.scope || null,
     project: {
-      organization: context.scope?.organization?.slug || null,
-      slug: context.scope?.project?.slug || null,
-      name: context.scope?.project?.name || null,
-      visibility: context.scope?.project?.visibility || null
+      organization: normalized.scope?.organization?.slug || null,
+      slug: normalized.scope?.project?.slug || null,
+      name: normalized.scope?.project?.name || null,
+      visibility: normalized.scope?.project?.visibility || null
     },
-    build: context.build || null,
+    build: normalized.build || null,
     baseline: {
-      selected: context.baseline?.selected || null,
-      selection_reason: context.baseline?.selection_reason || null
+      selected: normalized.baseline?.selected || null,
+      selection_reason: normalized.baseline?.selection_reason || null
     },
-    status: formatAgentStatus(context.status),
-    summary: formatAgentSummary(context, comparisons),
+    status: normalized.status || null,
+    summary: normalized.summary || null,
+    signature_properties: normalized.signature_properties ?? null,
+    evidence_limit: evidenceLimit,
+    evidence_returned: evidence.length,
+    evidence_truncated: evidenceTruncated,
     evidence,
-    links: context.links || {},
-    preview: context.preview || null,
-    next_actions: buildAgentNextActions(context, comparisonSummary)
+    links: normalized.links || {},
+    preview: normalized.preview || null,
+    suggested_commands: buildSuggestedCommands(normalized, evidence, evidenceTruncated)
   };
   if (includeSet.has('screenshots')) {
-    payload.screenshots = context.screenshots || [];
+    payload.screenshots = normalized.screenshots || [];
   }
   if (includeSet.has('comments')) {
-    payload.comments = context.comments || {};
+    payload.comments = normalized.comments || {};
   }
   return payload;
 }
@@ -396,12 +562,17 @@ function formatNeedsReview(status = {}) {
   if (!status || status.needs_review == null) {
     return null;
   }
-  let pending = status.pending_comparisons || 0;
-  let unresolved = status.unresolved_comments || 0;
   if (!status.needs_review) {
     return 'no';
   }
-  return `yes · ${pending} comparisons · ${unresolved} unresolved comments`;
+  let details = [];
+  if (status.pending_comparisons != null) {
+    details.push(`${status.pending_comparisons} comparisons`);
+  }
+  if (status.unresolved_comments != null) {
+    details.push(`${status.unresolved_comments} unresolved comments`);
+  }
+  return details.length > 0 ? `yes · ${details.join(' · ')}` : 'yes';
 }
 function formatConfirmedRegionLabels(regions = []) {
   return regions.map(region => region.label).filter(Boolean).slice(0, 3).join(' · ');
@@ -436,42 +607,131 @@ function printComparisonList(output, comparisons = [], {
     }
   }
 }
+function getGroupDisplayState(group = {}) {
+  let aggregate = group.aggregate_status || {};
+  if ((aggregate.failed_count ?? 0) > 0) return 'failed';
+  if (aggregate.has_rejected === true) return 'rejected';
+  if (aggregate.has_changes === true) return 'changed';
+  if (aggregate.has_new === true) return 'new';
+  if (aggregate.needs_review === true) return 'needs review';
+  if (aggregate.all_approved === true) return 'approved';
+  return null;
+}
+function formatViewport(viewport) {
+  if (!viewport) {
+    return null;
+  }
+  return `${viewport.width ?? '?'}×${viewport.height ?? '?'}`;
+}
+function printScreenshotGroups(output, groups = [], {
+  limit = 8
+} = {}) {
+  let colors = output.getColors();
+  let visibleGroups = groups.slice(0, limit);
+  output.print('  Screenshot groups');
+  for (let group of visibleGroups) {
+    let displayState = getGroupDisplayState(group);
+    let tone = getStatusTone(colors, displayState);
+    let aggregate = group.aggregate_status || {};
+    let details = [];
+    if (group.variant_count != null) {
+      details.push(`${group.variant_count} variants`);
+    }
+    if (aggregate.needs_review_count != null) {
+      details.push(`${aggregate.needs_review_count} needs review`);
+    }
+    if (aggregate.failed_count != null && aggregate.failed_count > 0) {
+      details.push(`${aggregate.failed_count} failed`);
+    }
+    if (aggregate.max_diff_percentage != null) {
+      details.push(`${aggregate.max_diff_percentage}% max diff`);
+    }
+    output.print(`  ${colors.bold(group.name)}${displayState ? ` ${tone(displayState.toUpperCase())}` : ''}`);
+    if (details.length > 0) {
+      output.print(`    ${colors.dim(details.join(' · '))}`);
+    }
+    for (let variant of group.variants.slice(0, 3)) {
+      let variantDetails = [variant.review_state, variant.browser, formatViewport(variant.viewport)].filter(Boolean);
+      output.print(`    ${getStatusTone(colors, variant.result)((variant.result || 'unknown').toUpperCase())}${variantDetails.length > 0 ? ` · ${colors.dim(variantDetails.join(' · '))}` : ''}`);
+    }
+  }
+  if (groups.length > visibleGroups.length) {
+    output.print(`    ${colors.dim(`...${groups.length - visibleGroups.length} more groups`)}`);
+  }
+}
+function printFailedCaptures(output, captures = []) {
+  let colors = output.getColors();
+  output.print('  Failed captures');
+  for (let capture of captures.slice(0, 8)) {
+    let details = [capture.error_message, capture.browser, formatViewport(capture.viewport), capture.screenshot.url].filter(Boolean);
+    output.print(`  ${colors.bold(capture.name)} ${colors.brand.error('FAILED')}`);
+    if (details.length > 0) {
+      output.print(`    ${colors.dim(details.join(' · '))}`);
+    }
+  }
+}
+function formatReviewSummary(review = {}) {
+  let details = [review.pending != null ? `${review.pending} pending` : null, review.approved != null ? `${review.approved} approved` : null, review.rejected != null ? `${review.rejected} rejected` : null].filter(Boolean);
+  return details.length > 0 ? details.join(' · ') : null;
+}
 function displayBuildContext(output, context) {
   output.header('context', 'build');
+  let normalizedContext = normalizeBuildContext(context);
   let colors = output.getColors();
-  let buildTone = getStatusTone(colors, context.build.status);
-  let comparisons = context.comparisons || [];
-  let screenshots = context.screenshots || [];
-  let reviewSummary = context.summary?.review || {};
-  let commentsSummary = context.summary?.comments || {};
-  let needsReview = formatNeedsReview(context.status);
-  let baseline = context.baseline?.selected || null;
-  output.print(`  ${colors.bold(context.build.name || context.build.id)} ${buildTone((context.build.status || 'unknown').toUpperCase())}`);
-  output.print(`  ${colors.dim(`@${context.scope.organization.slug}/${context.scope.project.slug}`)}`);
+  let build = normalizedContext.build || {};
+  let buildTone = getStatusTone(colors, build.status);
+  let comparisons = normalizedContext.comparisons;
+  let groups = normalizedContext.groups;
+  let screenshots = normalizedContext.screenshots || [];
+  let failedCaptures = normalizedContext.failed_captures;
+  let reviewSummary = formatReviewSummary(normalizedContext.summary?.review);
+  let commentsSummary = normalizedContext.summary?.comments || {};
+  let needsReview = formatNeedsReview(normalizedContext.status);
+  let baseline = normalizedContext.baseline?.selected || null;
+  let comparisonCount = normalizedContext.summary?.comparisons?.total ?? normalizedContext.total_comparisons ?? (Array.isArray(context.comparisons) ? comparisons.length : null);
+  let screenshotCount = normalizedContext.summary?.screenshots?.total ?? normalizedContext.screenshot_count ?? (Array.isArray(context.screenshots) ? screenshots.length : null);
+  output.print(`  ${colors.bold(build.name || build.id || 'unknown build')} ${buildTone((build.status || 'unknown').toUpperCase())}`);
+  output.print(`  ${colors.dim(`@${normalizedContext.scope?.organization?.slug || 'unknown'}/${normalizedContext.scope?.project?.slug || 'unknown'}`)}`);
   output.blank();
-  output.labelValue('Comparisons', String(comparisons.length));
-  if (screenshots.length > 0) {
-    output.labelValue('Screenshots', String(screenshots.length));
+  if (comparisonCount != null) {
+    output.labelValue('Comparisons', String(comparisonCount));
+  }
+  if (groups.length > 0) {
+    output.labelValue('Screenshot Groups', String(groups.length));
+  }
+  if (screenshotCount != null) {
+    output.labelValue('Screenshots', String(screenshotCount));
   }
   if (baseline) {
-    output.labelValue('Baseline', `${baseline.name || baseline.id || 'selected'}${context.baseline.selection_reason ? ` · ${context.baseline.selection_reason}` : ''}`);
+    output.labelValue('Baseline', `${baseline.name || baseline.id || 'selected'}${normalizedContext.baseline.selection_reason ? ` · ${normalizedContext.baseline.selection_reason}` : ''}`);
   }
   if (needsReview) {
     output.labelValue('Needs Review', needsReview);
   }
-  output.labelValue('Review', `${reviewSummary.pending || 0} pending · ${reviewSummary.approved || 0} approved · ${reviewSummary.rejected || 0} rejected`);
-  output.labelValue('Memory', `${commentsSummary.build ?? getBuildCommentsCount(context)} build comments · ${commentsSummary.screenshot ?? getScreenshotCommentsCount(context)} screenshot comments · ${getReviewAssignmentsCount(context)} assignments`);
-  if (context.preview) {
-    let previewUrl = context.preview.preview_url || context.preview.url;
-    output.labelValue('Preview', `${context.preview.status || 'unknown'}${previewUrl ? ' · available' : ''}`);
+  if (reviewSummary) {
+    output.labelValue('Review', reviewSummary);
   }
-  if (context.links?.build_url) {
-    output.labelValue('Build URL', context.links.build_url);
+  let buildComments = commentsSummary.build ?? (Array.isArray(normalizedContext.comments?.build) ? getBuildCommentsCount(normalizedContext) : null);
+  let screenshotComments = commentsSummary.screenshot ?? (Number.isInteger(normalizedContext.comments?.screenshot_count) ? getScreenshotCommentsCount(normalizedContext) : null);
+  let assignments = Array.isArray(normalizedContext.review?.assignments) ? getReviewAssignmentsCount(normalizedContext) : null;
+  let memory = [buildComments != null ? `${buildComments} build comments` : null, screenshotComments != null ? `${screenshotComments} screenshot comments` : null, assignments != null ? `${assignments} assignments` : null].filter(Boolean);
+  if (memory.length > 0) {
+    output.labelValue('Memory', memory.join(' · '));
   }
-  if (comparisons.length > 0) {
+  if (normalizedContext.preview) {
+    let previewUrl = normalizedContext.preview.preview_url || normalizedContext.preview.url;
+    output.labelValue('Preview', `${normalizedContext.preview.status || 'unknown'}${previewUrl ? ' · available' : ''}`);
+  }
+  if (normalizedContext.links?.build_url) {
+    output.labelValue('Build URL', normalizedContext.links.build_url);
+  }
+  if (groups.length > 0) {
+    output.blank();
+    printScreenshotGroups(output, groups);
+  }
+  if (failedCaptures.length > 0) {
     output.blank();
-    output.print('  Comparisons');
-    printComparisonList(output, comparisons);
+    printFailedCaptures(output, failedCaptures);
   }
 }
 function formatAgentBuildContext(context) {
@@ -631,13 +891,17 @@ export async function contextBuildCommand(buildId, options = {}, globalOptions =
       return;
     }
     let resolvedBuildId = resolveBuildContextId(buildId, runtime, deps);
+    let include = parseIncludeOption(options.include);
+    let query = globalOptions.json && options.agent && !options.full ? {
+      details: include.includes('diffs') ? 'diffs' : 'summary'
+    } : undefined;
     output.startSpinner('Fetching build context...');
-    let context = await runtime.provider.getBuildContext(resolvedBuildId);
+    let context = await runtime.provider.getBuildContext(resolvedBuildId, query);
     output.stopSpinner();
     if (globalOptions.json && options.agent && !options.full) {
       output.data(buildAgentBuildPayload(context, {
         source: runtime.source,
-        include: parseIncludeOption(options.include)
+        include
       }));
       output.cleanup();
       return;