firedrill-run 2.2.4 → 3.0.0

package/dist/cli/src/campaign-reports.js

@@ -0,0 +1,1215 @@
+import { APP_ORIGIN } from './http.js';
+import { workspaceLink } from './browser-links.js';
+import { api, openBrowser } from './auth.js';
+import { CliError } from './http.js';
+import { selectOne, terminalText } from './prompts.js';
+import { selectedWorkspace } from './world-access.js';
+import { identifier } from './world-contracts.js';
+import { reportExport, validateExport } from './report-exports.js';
+import { worldTimeReport } from './world-time-report.js';
+import { evidenceCommand, timelineCommand } from './evidence-bundles.js';
+import { serviceReceipts, validateReceiptOptions } from './service-receipts.js';
+import { trialActions, validateActionOptions } from './trial-actions.js';
+import { trialRecordedChecks, validateCheckOptions } from './trial-checks.js';
+import { trialStateReport, validateTrialStateOptions } from './trial-state.js';
+import { campaignWorldCommand } from './campaign-world.js';
+import { captureMatchesTrial, fileMatchesTrial } from '../../contracts/media-contracts.js';
+import { captureClipMatches } from '../../contracts/clip-contracts.js';
+import { coveragePageMatches } from '../../contracts/evidence-coverage-contracts.js';
+import { assessmentMatches, assessmentPageMatches, assessmentEvidenceMatches } from '../../contracts/assessment-contracts.js';
+import { checkpointLabel } from '../../contracts/trial-state-contracts.js';
+import { scoreCohortMatches, checkpointMatches, styleCohortMatches } from '../../contracts/assessment-aggregate-contracts.js';
+import { comparisonPageMatches, comparisonObservationsMatch } from '../../contracts/comparison-contracts.js';
+import { checkGroupsMatch, checkObservationsMatch, nativeCheckObservationMatches } from '../../contracts/native-check-contracts.js';
+import { compositeMatches, compositePageMatches, compositeGroupsMatch, compositeModelsMatch, compositeObservationsMatch } from '../../contracts/composite-contracts.js';
+import { targetUsageMatches, targetCompletionNotes, performanceGroupsMatch, performanceObservationsMatch } from '../../contracts/performance-contracts.js';
+import { findingsMatch, insightsMatch } from '../../contracts/insight-contracts.js';
+const scoreStatuses = { assessed: 'succeeded', 'not-assessable': 'not_assessable', 'not-applicable': 'not_applicable' };
+const assessmentLabels = { queued: 'Queued', preparing: 'Preparing evidence', submitted: 'Evaluating',
+    succeeded: 'Assessed', not_assessable: 'Not assessable', not_applicable: 'Not applicable', failed: 'Evaluation error', unknown: 'Reply unconfirmed', unavailable: 'Evidence unavailable' };
+const assessmentStates = new Set(['queued', 'preparing', 'submitted', 'succeeded', 'not_assessable', 'not_applicable', 'failed', 'unknown', 'unavailable']);
+const taskModes = new Set(['single_request', 'browser_workflow', 'adaptive_browser', 'desktop', 'process', 'event']);
+const trialStates = new Set(['planned', 'claimed', 'dispatching', 'running', 'reconciling', 'completed', 'failed',
+    'timed_out', 'canceled', 'platform_failed', 'platform_failed_before_start', 'canceled_before_start']);
+const trialChecks = { met: 'All checks met', unmet: 'Unmet checks', unassessed: 'Not assessed',
+    unavailable: 'Check result unavailable', missing: 'No available result' };
+const executionPhase = (value) => ({ 'Running trial': 'Running drill', 'Preparing trial': 'Preparing drill' }[value] ?? value);
+const activityLabel = (kind) => (kind.startsWith('trial.') ? `Drill ${kind.slice(6)}` : kind).replaceAll('.', ' ').replaceAll('_', ' ');
+const memoryPointLabel = (point) => point.kind === 'turn' ? `Turn ${point.turn}` : `Event ${point.event_key}`;
+const memoryCheckpointLabel = (probe) => probe.checkpoint ? memoryPointLabel(probe.checkpoint) : `Turn ${probe.checkpoint_turn}`;
+const memoryExposureLabels = (probe) => probe.exposures ? probe.exposures.map(memoryPointLabel).join(', ')
+    : probe.exposure_turns.map(turn => `Turn ${turn}`).join(', ');
+function trialListPath(prefix, options) {
+    const query = new URLSearchParams();
+    if (options.scenario)
+        query.set('scenario', identifier(options.scenario));
+    if (options.status)
+        query.set('status', options.status);
+    if (options.checks)
+        query.set('checks', options.checks);
+    if (options.cohort)
+        query.set('cohort', identifier(options.cohort));
+    if (options.assessmentStatus)
+        query.set('assessment_status', scoreStatuses[options.assessmentStatus]);
+    if (options.scoreBucket !== undefined)
+        query.set('score_bucket', options.scoreBucket);
+    return `${prefix}/trials${query.size ? `?${query}` : ''}`;
+}
+async function choosePage(title, path, scope, options, describe, confirm) {
+    let page = options.page ?? '1';
+    while (true) {
+        const data = await api(`${path}${path.includes('?') ? '&' : '?'}page=${page}&q=${encodeURIComponent(options.search ?? '')}`, { actor: scope.owner, signal: options.signal });
+        if (confirm && !confirm(data))
+            throw new CliError('report_unavailable', 'This saved report selection could not be confirmed. Reopen the report.');
+        const choices = data.results.map(value => ({ value: { kind: 'item', value }, ...describe(value) }));
+        if (Number(page) > 1)
+            choices.unshift({ value: { kind: 'previous' }, label: 'Previous page', detail: '' });
+        if (data.next)
+            choices.push({ value: { kind: 'next' }, label: 'Next page', detail: '' });
+        if (!data.count)
+            throw new CliError('report_empty', 'No matching saved reports are available.');
+        const choice = await selectOne(title, choices, options.signal);
+        if (choice.kind === 'item')
+            return choice.value;
+        page = String(Number(page) + (choice.kind === 'previous' ? -1 : 1));
+    }
+}
+function duration(value) {
+    if (value === null)
+        return 'Not recorded';
+    if (!/^[0-9]{1,40}$/.test(value))
+        throw new CliError('report_unavailable', 'The recorded timing could not be read.');
+    const milliseconds = BigInt(value), seconds = milliseconds / 1000n;
+    if (milliseconds < 1000n)
+        return `${milliseconds}ms`;
+    return `${seconds / 3600n}h ${seconds / 60n % 60n}m ${seconds % 60n}s`;
+}
+function entryLabel(row, agent) {
+    if (row.task_phase === 'submission')
+        return `${agent} submission response`;
+    if (row.task_phase === 'poll')
+        return `${agent} status response`;
+    return taskModes.has(row.interaction_mode) ? row.role === 'user' ? 'Task input' : `${agent} output`
+        : row.role === 'user' ? 'Synthetic user' : agent;
+}
+function completionLines(value) {
+    if (!value)
+        return [];
+    const names = { pending: 'Pending', completed: 'Completed', failed: 'Failed', unconfirmed: 'Completion not confirmed', rejected: 'Submission rejected' };
+    return [`Source job status: ${names[value.state]}${'status_value' in value && value.status_value ? ` (${value.status_value})` : ''}`,
+        `${value.poll_requests.toLocaleString()} status read attempts; ${value.retained_responses.toLocaleString()} of ${value.responses.toLocaleString()} response bodies recorded.`,
+        ...(value.omitted_responses ? ['Some response bodies could not be retained. Missing content is not an empty or successful result.'] : []),
+        ...(value.reason === 'evidence_unavailable' ? ['Response recording could not finish. Available observations are preserved.'] : []),
+        'Job status is not an evaluation score. Status reads do not submit the task again.'];
+}
+function streamLines(streams) {
+    return streams.flatMap(stream => [`Attempt ${stream.attempt_number}: ${stream.available_responses.toLocaleString()} response entries available${stream.recorded_responses === null ? '.' : ` of ${stream.recorded_responses.toLocaleString()} recorded.`}`,
+        ...(!stream.consistent ? ['The response summary does not match the retained entries. Completeness cannot be confirmed.'] : []),
+        ...(!stream.input_available ? ['The original task input is unavailable here.'] : []),
+        ...(!stream.final_summary_available ? ['The final response summary has not been retained.'] : []),
+        ...(stream.unavailable_responses !== null && stream.unavailable_responses > 0 ? ['Some recorded responses are unavailable in this report.'] : [])]);
+}
+function conversationLines(streams) {
+    return streams.flatMap(stream => [
+        `Conversation attempt ${stream.attempt_number}: ${stream.available_inputs.toLocaleString()}${stream.progress ? ` of ${stream.progress.inputs.toLocaleString()} submitted` : ''} inputs and ${stream.available_responses.toLocaleString()}${stream.progress ? ` of ${stream.progress.responses.toLocaleString()} observed` : ''} replies available.`,
+        ...(!stream.consistent ? ['The conversation summary could not be reconciled. Completeness is unknown.'] : []),
+        ...(!stream.final_summary_available ? ['The final conversation summary is unavailable.'] : []),
+        ...(stream.progress?.state === 'interrupted' ? ['The conversation did not finish; retained messages are preserved.'] : []),
+        ...(stream.progress && (stream.progress.omitted_inputs + stream.progress.omitted_responses > 0
+            || stream.available_inputs < stream.progress.recorded_inputs || stream.available_responses < stream.progress.recorded_responses)
+            ? ['Some conversation content is unavailable, not an empty or successful answer.'] : [])
+    ]);
+}
+function captureLines(value) {
+    if (!value)
+        return [];
+    if (!value.window_observed)
+        return ['The task request did not reach the capture window. Tool usage is unknown.'];
+    return [`Mapped task requests: ${value.observed.toLocaleString()} observed; ${value.captured.toLocaleString()} payloads captured; ${value.unavailable.toLocaleString()} unavailable; ${value.unfinished.toLocaleString()} unfinished at task return.`,
+        ...(value.pending_untracked ? ['Additional unfinished requests could not be tracked individually.'] : []),
+        'Only mapped service traffic during the task. Private or unsupported payloads are withheld; captured files may still be awaiting cloud retention.'];
+}
+function operationLines(streams) {
+    return streams.flatMap(stream => [
+        `${stream.channel === 'http' ? 'Mapped HTTP/MCP' : stream.channel === 'source' ? 'Agent-reported calls' : 'Handler'} attempt ${stream.attempt_number}: ${(stream.coverage?.observed ?? stream.starts_available).toLocaleString()} ${stream.coverage ? stream.channel === 'source' ? 'calls reported' : 'requests observed' : 'entries available'}; ${stream.receipts_available.toLocaleString()} payloads available${stream.coverage ? `; ${stream.coverage.withheld.toLocaleString()} withheld; ${stream.coverage.unfinished.toLocaleString()} ${stream.channel === 'http' ? 'responses unknown' : stream.channel === 'source' ? 'reports incomplete' : 'completions unknown'}` : ''}.`,
+        ...(!stream.consistent ? ['The request summary could not be reconciled. Completeness is unknown.'] : []),
+        ...(!stream.final_summary_available ? ['The final request summary is unavailable.'] : []),
+        ...(stream.coverage && (stream.receipts_available < stream.coverage.retained || stream.starts_available < stream.coverage.observed)
+            ? ['Some recorded operation evidence is unavailable here.'] : [])
+    ]);
+}
+function speechLines(value) {
+    if (!value)
+        return [];
+    return [
+        ...(value.started_at === null || value.ended_at === null ? [] : [`${value.basis === 'session_audio' ? 'Audio timing' : 'Transcription delivery'}: ${new Date(value.started_at * 1000).toISOString()} to ${new Date(value.ended_at * 1000).toISOString()}`]),
+        ...(value.duration_ms === null ? [] : [`${value.basis === 'session_audio' ? 'Observed audio interval' : 'Transcription delivery span'}: ${value.duration_ms}ms`]),
+        ...(value.reported_latency_ms === null ? [] : [`Reported turn latency: ${value.reported_latency_ms.toLocaleString()}ms`]),
+        ...(value.interrupted === null ? [] : [`Reported interrupted: ${value.interrupted ? 'yes' : 'no'}`])
+    ];
+}
+function speechSummaryLines(groups, agent) {
+    return groups.flatMap(row => row.audio_messages || row.delivery_messages || row.latency_observations || row.interruption_observations ? [
+        `Speech measurements: ${row.role === 'assistant' ? agent : 'Synthetic user'}, attempt ${row.attempt_number}`,
+        ...(row.audio_duration_ms === null ? [] : [`Observed audio intervals: ${row.audio_duration_ms}ms across ${row.audio_messages} of ${row.messages} messages`]),
+        ...(row.delivery_duration_ms === null ? [] : [`Transcription delivery spans: ${row.delivery_duration_ms}ms across ${row.delivery_messages} of ${row.messages} messages; not speaking time`]),
+        ...(row.mean_reported_latency_ms === null ? [] : [`Reported turn latency: mean ${row.mean_reported_latency_ms}ms, range ${row.min_reported_latency_ms}ms to ${row.max_reported_latency_ms}ms from ${row.latency_observations} observations`]),
+        ...(row.interruption_observations ? [`Reported interruptions: ${row.interrupted} of ${row.interruption_observations} observed messages`] : [])
+    ] : []);
+}
+async function trialCoverageReport(path, scope, interactive, options, output, supplied, agent = 'Agent') {
+    if (supplied !== undefined && !['messages', 'actions'].includes(supplied)
+        || options.search !== undefined && (!/^[1-9][0-9]{0,9}$/.test(options.search) || Number(options.search) > 2 ** 31 - 1))
+        throw new CliError('arguments_invalid', 'Choose coverage messages|actions. --search filters one positive attempt number.', 2);
+    const kind = supplied ?? (interactive ? await selectOne('Evidence coverage', [
+        { value: 'messages', label: 'Messages and speech' }, { value: 'actions', label: 'Tool evidence' },
+    ], options.signal) : 'messages');
+    let page = Number(options.page ?? 1);
+    while (true) {
+        const params = new URLSearchParams({ kind, page: String(page), q: options.search ?? '' });
+        const data = await api(`${path}/coverage?${params}`, {
+            actor: scope.owner, workspace: scope.workspace, signal: options.signal
+        });
+        if (!coveragePageMatches(data, kind, options.search))
+            throw new CliError('trial_coverage_unavailable', 'The selected evidence coverage could not be confirmed.');
+        const parts = path.split('/');
+        output(data, [...data.results.flatMap(row => [`Attempt ${row.attempt_number.toLocaleString()}`,
+                ...operationLines(row.operation_streams), ...streamLines(row.task_message_streams), ...conversationLines(row.message_streams),
+                ...speechSummaryLines(row.speech_measurements, agent), ...row.voice_streams.flatMap(stream => [
+                    `Speech transcript: ${stream.available_messages.toLocaleString()} messages retained`,
+                    ...(!stream.consistent ? ['Transcript coverage could not be reconciled.'] : []),
+                    ...(!stream.canonical_transcript_available ? ['The final transcript is unavailable; retained speech observations may be incomplete.'] : []),
+                    ...((stream.progress?.omitted_messages ?? 0) > 0 ? ['Some speech observations could not be retained.'] : [])
+                ])]),
+            ...(!data.count ? [options.search ? 'No evidence matches this attempt number.' : 'No coverage evidence is available.'] : []),
+            `Page ${data.page}; ${data.count.toLocaleString()} attempts with retained ${kind === 'actions' ? 'tool' : 'message'} evidence.`,
+            ...(data.next ? [`Continue: firedrill report ${parts.at(-3)} drill ${parts.at(-1)} coverage ${kind} --workspace ${scope.workspace} --page ${page + 1}${options.search ? ' --search ' + options.search : ''}${options.json ? ' --json' : ''}`] : [])].join('\n'));
+        if (!interactive)
+            return;
+        const choice = await selectOne('Coverage page', [...(page > 1 ? [{ value: 'previous', label: 'Previous page' }] : []),
+            ...(data.next ? [{ value: 'next', label: 'Next page' }] : []), { value: 'done', label: 'Done' }], options.signal);
+        if (choice === 'done')
+            return;
+        page += choice === 'next' ? 1 : -1;
+    }
+}
+async function trialReport(args, prefix, scope, interactive, options, output) {
+    if (options.checkpoint || args[3] && !['messages', 'actions', 'requests', 'checks', 'check-observation', 'coverage', 'state', 'captures', 'desktop-captures', 'clips', 'recordings', 'schedule'].includes(args[3]) || args[4] && !args[2]
+        || (args[3] === 'captures' || args[3] === 'desktop-captures' || args[3] === 'recordings') && (args[4] || options.search)
+        || args[4] && !['schedule', 'coverage', 'state'].includes(args[3]) && (options.page || options.search)
+        || args[3] === 'schedule' && (args.length > 6 || args[4] && !/^[a-f0-9]{64}$/.test(args[4]) || args[5] && !['changes', 'conditions'].includes(args[5]))) {
+        throw new CliError('arguments_invalid', 'Use report <campaign> drill [drill] [messages|actions|requests [entry]|checks [position]|check-observation <id>|coverage [messages|actions]|captures|desktop-captures|clips [clip]|recordings|schedule [event] [changes|conditions]]. Paging applies to lists.', 2);
+    }
+    if (args[3] === 'clips' && (options.search || args.length > 5))
+        throw new CliError('arguments_invalid', 'Use clips [clip-id] with --page for its history. Preparation, playback and downloads open in the browser.', 2);
+    const auth = { actor: scope.owner, workspace: scope.workspace, signal: options.signal };
+    let execution = args[2] ? identifier(args[2]) : undefined;
+    const listPath = trialListPath(prefix, options);
+    if (!execution && !interactive) {
+        const data = await api(`${listPath}${listPath.includes('?') ? '&' : '?'}page=${options.page ?? '1'}&q=${encodeURIComponent(options.search ?? '')}`, auth);
+        const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+        output(data, [`${data.count.toLocaleString()} matching drills`, ...data.results.map(row => `Drill ${row.position + 1}: ${row.scenario_name} · ${row.state}\n${trialChecks[row.checks] ?? 'Unavailable'}\n${row.id}`),
+            ...(data.next ? [`Continue: firedrill report ${prefix.split('/').at(-1)} drill --workspace ${scope.workspace} --page ${data.page + 1}${options.search ? ' --search ' + quote(options.search) : ''}${options.status ? ' --status ' + options.status : ''}${options.checks ? ' --checks ' + options.checks : ''}${options.scenario ? ' --scenario ' + identifier(options.scenario) : ''}${options.cohort ? ' --cohort ' + identifier(options.cohort) : ''}${options.assessmentStatus ? ' --assessment-status ' + options.assessmentStatus : ''}${options.scoreBucket !== undefined ? ' --score-bucket ' + options.scoreBucket : ''}${options.json ? ' --json' : ''}`] : [])].join('\n\n'));
+        return;
+    }
+    const chosen = !execution;
+    if (!execution)
+        execution = identifier((await choosePage('Drill', listPath, scope, options, row => ({ label: `Drill ${row.position + 1}: ${row.scenario_name}`, detail: `${row.state}; ${trialChecks[row.checks] ?? 'Unavailable'}` }))).id);
+    const path = `${prefix}/trials/${execution}`;
+    if (args[3] === 'check-observation') {
+        if (args.length !== 5 || !args[4] || options.page !== undefined || options.search !== undefined || options.status !== undefined
+            || options.evidenceKind !== undefined || options.checks !== undefined || options.scenario !== undefined)
+            throw new CliError('arguments_invalid', 'Choose one original check-observation ID without list filters.', 2);
+        const observation = identifier(args[4]), campaign = identifier(prefix.split('/').at(-1));
+        const row = await api(`${path}/check-observations/${observation}`, auth);
+        if (!nativeCheckObservationMatches(row, { workspace: scope.workspace, campaign, execution, observation }))
+            throw new CliError('trial_check_unavailable', 'The selected check observation could not be confirmed.');
+        output(row, [`${terminalText(row.name)}: ${!row.reported ? 'Not reported' : row.status === 'met' ? 'Met' : row.status === 'unmet' ? 'Unmet' : 'Unconfirmed'}`,
+            nativeCheckMethods[row.method], ...(row.reason !== null ? [terminalText(row.reason)] : row.reason_truncated
+                ? ['The explanation is too large to show inline. Read the saved result.']
+                : [row.reported ? 'No reason recorded.' : 'This check was declared but was not included in the retained result.']),
+            ...(row.reason_truncated ? [`Saved result: firedrill report ${campaign} drill ${execution} evidence ${row.evidence_id} --workspace ${scope.workspace}`] : []),
+            workspaceLink(scope.workspace, `/campaigns/${campaign}/trials/${execution}?view=assessment&check_observation=${observation}`)].join('\n'));
+        return;
+    }
+    if (args[3] === 'state') {
+        await trialStateReport(args.slice(4), path, scope, interactive, options, output);
+        return;
+    }
+    if (args[3] === 'checks') {
+        await trialRecordedChecks(path, scope, interactive, options, output, args[4]);
+        return;
+    }
+    if (args[3] === 'coverage') {
+        await trialCoverageReport(path, scope, interactive, options, output, args[4]);
+        return;
+    }
+    const data = await api(path, auth);
+    if (data.id !== execution || data.campaign_id !== prefix.split('/').at(-1))
+        throw new CliError('trial_report_unavailable', 'This retained drill report could not be confirmed. Reopen its campaign.');
+    let inspect = args[3];
+    if (!inspect) {
+        if (args[2] && (options.page || options.search))
+            throw new CliError('arguments_invalid', 'Search and paging apply to drill, input/output or action lists.', 2);
+        const task = data.conversation.interaction_modes.length > 0 && data.conversation.interaction_modes.every(mode => taskModes.has(mode));
+        output(data, [`Drill ${data.number}: ${data.scenario.name} · ${data.execution_state.replaceAll('_', ' ')}`,
+            data.agent.name, data.scenario.instruction, ...(data.problem ? [data.problem] : []), ...(data.evidence_notice ? [data.evidence_notice] : []),
+            data.execution_location === 'local' ? 'Local device execution. Evidence is device-reported, not independently observed by a managed sandbox.' : 'Managed sandbox execution.',
+            ...(data.starting_data ? [`Starting data: ${data.starting_data.edit_count} saved edits selected.`,
+                data.starting_data.application ? `Applied before scenario setup at ${data.starting_data.application.applied_at}; ${data.starting_data.application.rows_affected} rows directly affected. This is not the final state.`
+                    : data.starting_data.problem ?? (data.starting_data.application_state === 'pending'
+                        ? 'Starting-data application evidence is pending. Read this same drill again; selection alone does not confirm application.'
+                        : 'The original starting-data application record is unavailable.')] : []),
+            ...(data.application_continuation ? [`Saved starting state: ${data.application_continuation.selection.scope === 'supported_application_and_native_state'
+                    ? 'application and supported synthetic service data' : 'application with fresh synthetic services'}.`,
+                data.application_continuation.state === 'observed' && data.application_continuation.observed_at
+                    ? `Restoration reported at ${data.application_continuation.observed_at}${data.application_continuation.provenance === 'customer_device' ? ' by the local runner' : ' by the managed runtime'}.`
+                    : 'Restoration evidence is not available. Selection alone does not confirm application.',
+                'New process only. External accounts, live process memory and elapsed wall time are not restored.'] : []),
+            `${data.conversation.message_count.toLocaleString()} ${task ? 'inputs and outputs' : 'messages'} retained; ${data.actions.count.toLocaleString()} tool actions; ${data.service_requests.toLocaleString()} mapped service requests`,
+            `${data.state_observations.toLocaleString()} state observations`,
+            ...(data.voice_capture.enabled || data.voice_capture.retained ? [`${data.voice_capture.recordings.toLocaleString()} audio recordings; ${data.voice_capture.segments.toLocaleString()} partial clips retained`] : []),
+            ...(data.browser_capture.enabled || data.browser_capture.retained ? [
+                `${data.browser_capture.images.toLocaleString()} browser images available from ${data.browser_capture.retained.toLocaleString()} retained capture records`,
+                ...(data.browser_capture.latest ? [`Latest capture: ${data.browser_capture.latest.captured_at}; ${data.browser_capture.latest.state}`] : [])
+            ] : []),
+            ...(data.desktop_capture.enabled || data.desktop_capture.retained ? [
+                `${data.desktop_capture.images.toLocaleString()} desktop images available from ${data.desktop_capture.retained.toLocaleString()} retained capture records`
+            ] : []),
+            ...captureLines(data.actions.capture),
+            ...completionLines(data.conversation.task_completion ?? data.conversation.task_progress),
+            ...(data.coverage.message_attempts || data.coverage.action_attempts ? [`Evidence coverage: ${data.coverage.message_attempts.toLocaleString()} attempts with messages; ${data.coverage.action_attempts.toLocaleString()} with tool evidence.`,
+                `Inspect: firedrill report ${prefix.split('/').at(-1)} drill ${execution} coverage --workspace ${scope.workspace}`] : []),
+            ...(data.conversation.duration_ms === null ? [] : [`${task ? 'Task' : 'Conversation'} duration: ${data.conversation.duration_ms.toLocaleString()}ms`]),
+            !data.recorded_checks.result_retained ? 'The original check result is not available.' : data.recorded_checks.available
+                ? `${data.recorded_checks.count.toLocaleString()} checks recorded during execution.` : 'Recorded checks could not be read. Inspect their original result in Files.',
+            workspaceLink(scope.workspace, `/campaigns/${args[0] ?? prefix.split('/').at(-1)}/trials/${execution}`)].join('\n'));
+        if (!interactive)
+            return;
+        inspect = await selectOne('Inspect drill', [...(data.conversation.available ? [{ value: 'messages', label: task ? 'Input and output' : 'Conversation' }] : []),
+            ...(data.actions.count ? [{ value: 'actions', label: 'Tool actions' }] : []),
+            ...(data.service_requests ? [{ value: 'requests', label: 'Mapped service receipts' }] : []),
+            ...(data.state_observations ? [{ value: 'state', label: 'Observed state changes' }] : []),
+            ...((data.recorded_checks.count ?? 0) > 0 || data.recorded_checks.result_retained && !data.recorded_checks.available ? [{ value: 'checks', label: 'Recorded checks' }] : []),
+            ...(data.coverage.message_attempts || data.coverage.action_attempts ? [{ value: 'coverage', label: 'Evidence coverage' }] : []),
+            ...(data.browser_capture.enabled || data.browser_capture.retained ? [{ value: 'captures', label: 'Browser captures' }] : []),
+            ...(data.desktop_capture.enabled || data.desktop_capture.retained ? [{ value: 'desktop-captures', label: 'Desktop captures' }] : []),
+            ...(data.browser_capture.retained || data.desktop_capture.retained ? [{ value: 'clips', label: 'Video clips from retained captures' }] : []),
+            ...(data.voice_capture.retained ? [{ value: 'recordings', label: 'Audio recordings' }] : []),
+            { value: 'schedule', label: 'World schedule' }, { value: 'done', label: 'Done' }], options.signal);
+    }
+    const listOptions = chosen ? { ...options, page: undefined, search: undefined } : options;
+    if (inspect === 'state') {
+        await trialStateReport([], path, scope, interactive, listOptions, output);
+        return;
+    }
+    if (inspect === 'coverage') {
+        await trialCoverageReport(path, scope, interactive, listOptions, output, undefined, data.agent.name);
+        return;
+    }
+    if (inspect === 'checks') {
+        await trialRecordedChecks(path, scope, interactive, listOptions, output);
+        return;
+    }
+    if (inspect === 'requests') {
+        await serviceReceipts(`${path}/requests`, scope, listOptions, interactive, output, `firedrill report ${identifier(prefix.split('/').at(-1))} drill ${execution} requests`, args[4]);
+        return;
+    }
+    if (inspect === 'schedule') {
+        await worldTimeReport(path, scope, interactive, listOptions, output, args[4], args[5]);
+        return;
+    }
+    if (inspect === 'recordings') {
+        const page = await api(`${path}/files?kind=audio&page=${listOptions.page ?? '1'}`, auth);
+        if (page.results.some(row => row.audio === null || !fileMatchesTrial(row, path)))
+            throw new CliError('report_unavailable', 'The selected drill recordings could not be confirmed. Reopen the report.');
+        output(page, [...page.results.map(row => `${row.label ?? 'Audio recording'}${row.audio ? ` · ${row.audio.duration_ms.toLocaleString()}ms · ${row.audio.partial && row.audio.segment ? `Partial clip at ${(row.audio.segment.start_frame / row.audio.segment.sample_rate).toLocaleString(undefined, { maximumFractionDigits: 1 })}s` : row.audio.channels === 2 ? 'Stereo' : 'Mono'}` : ''}\n${row.id}`),
+            `Page ${page.page} of ${Math.max(1, Math.ceil(page.count / page.page_size))}`,
+            `Listen at 1×, 2× or 4×, or download: ${workspaceLink(scope.workspace, `/campaigns/${prefix.split('/').at(-1)}/trials/${execution}?view=files`)}`].join('\n\n'));
+        return;
+    }
+    if (inspect === 'clips') {
+        const browser = (clip) => {
+            const url = new URL(`/campaigns/${prefix.split('/').at(-1)}/trials/${execution}`, APP_ORIGIN);
+            url.searchParams.set('workspace', scope.workspace);
+            url.searchParams.set('view', 'session');
+            if (clip) {
+                url.searchParams.set('clip', clip.id);
+                url.searchParams.set('capture', clip.source_kind);
+            }
+            url.hash = 'capture-clips';
+            return url.href;
+        };
+        if (args[4]) {
+            const row = await api(`${path}/capture-clips/${identifier(args[4])}`, auth);
+            if (!captureClipMatches(row, `${path}/capture-clips`, identifier(args[4])))
+                throw new CliError('report_unavailable', 'The selected capture clip could not be confirmed. Reopen the report.');
+            output(row, [`Capture clip ${row.id}: ${row.state}`, `${row.frames.toLocaleString()} ${row.source_kind} captures`,
+                `${row.started_at} to ${row.ended_at}`, 'Browser-created playback of retained images, not continuous footage or a new target run.',
+                ...(row.problem ? [row.problem] : []), ...(row.file ? [`MP4: ${row.file.size.toLocaleString()} bytes`] : []), browser(row)].join('\n'));
+            if (interactive && options.openBrowser && await selectOne('Open capture clip?', [{ value: true, label: 'Open in browser' }, { value: false, label: 'Stay here' }], options.signal))
+                await openBrowser(browser(row));
+            return;
+        }
+        const clips = await api(`${path}/capture-clips?page=${listOptions.page ?? '1'}`, auth);
+        if (clips.results.some(row => !captureClipMatches(row, `${path}/capture-clips`)))
+            throw new CliError('report_unavailable', 'The capture clip history could not be confirmed. Reopen the report.');
+        output(clips, [...clips.results.map(row => `${row.started_at} · ${row.source_kind} · ${row.frames.toLocaleString()} captures · ${row.state}\n${row.id}`),
+            ...(!clips.count ? ['No capture clips have been saved.'] : []), `Page ${clips.page}; ${clips.count.toLocaleString()} clips.`,
+            ...(clips.next ? [`Continue with --page ${clips.page + 1}.`] : []), 'Create, resume, cancel, play or download a clip in the existing capture inspector.', browser()].join('\n\n'));
+        if (interactive && options.openBrowser && await selectOne('Capture clips', [{ value: true, label: 'Open capture inspector' }, { value: false, label: 'Stay here' }], options.signal))
+            await openBrowser(browser());
+        return;
+    }
+    if (inspect === 'captures' || inspect === 'desktop-captures') {
+        const desktop = inspect === 'desktop-captures';
+        const page = await api(`${path}/${inspect}?page=${listOptions.page ?? '1'}`, auth);
+        if (page.results.some(row => !captureMatchesTrial(row, path, desktop)))
+            throw new CliError('report_unavailable', 'The selected drill captures could not be confirmed. Reopen the report.');
+        output(page, [...page.results.map(row => `${row.captured_at} · ${desktop ? 'Agent desktop' : row.phase === 'session' ? 'Agent browser' : `Turn ${row.turn_index + 1} · ${row.phase.replaceAll('_', ' ')}`} · ${row.state}\n${row.id}`),
+            `Page ${page.page} of ${Math.max(1, Math.ceil(page.count / page.page_size))}`,
+            `View or replay captures at 1×, 2× or 4×: ${workspaceLink(scope.workspace, `/campaigns/${prefix.split('/').at(-1)}/trials/${execution}?view=session${desktop ? '&capture=desktop' : ''}`)}`].join('\n\n'));
+        return;
+    }
+    if (inspect === 'actions') {
+        await trialActions(path, scope, interactive, listOptions, output, args[4]);
+        return;
+    }
+    if (inspect !== 'messages')
+        return;
+    if (args[4]) {
+        const row = await api(`${path}/messages/${identifier(args[4])}`, { ...auth, maximumResponseBytes: 16 * 1024 ** 2 });
+        output(row, [`${entryLabel(row, data.agent.name)}${row.http_status === null ? '' : ` · HTTP ${row.http_status}`}\n${row.content}`, ...speechLines(row.speech)].join('\n'));
+        return;
+    }
+    if (!interactive) {
+        const page = await api(`${path}/messages?page=${listOptions.page ?? '1'}&q=${encodeURIComponent(listOptions.search ?? '')}`, auth);
+        output(page, [...page.results.map(row => [`${entryLabel(row, data.agent.name)}${row.http_status === null ? '' : ` · HTTP ${row.http_status}`}\n${row.content}${row.truncated ? '\nFull content: request this entry by ID.' : ''}`, ...speechLines(row.speech), row.id].join('\n')),
+            `Page ${page.page} of ${Math.max(1, Math.ceil(page.count / page.page_size))}`].join('\n\n'));
+        return;
+    }
+    const selected = await choosePage('Recorded input or output', `${path}/messages`, scope, listOptions, row => ({ label: `${row.position + 1}. ${entryLabel(row, data.agent.name)}`, detail: row.http_status === null ? '' : `HTTP ${row.http_status}` }));
+    const row = await api(`${path}/messages/${identifier(selected.id)}`, { ...auth, maximumResponseBytes: 16 * 1024 ** 2 });
+    output(row, [`${entryLabel(row, data.agent.name)}${row.http_status === null ? '' : ` · HTTP ${row.http_status}`}\n${row.content}`, ...speechLines(row.speech)].join('\n'));
+}
+async function findingsReport(supplied, prefix, scope, interactive, options, output) {
+    if (options.checkpoint !== undefined)
+        throw new CliError('arguments_invalid', 'Checkpoint selection applies to memory reports, not scenario findings.', 2);
+    if (supplied && (options.page !== undefined || options.search !== undefined))
+        throw new CliError('arguments_invalid', 'Paging and search apply to the findings directory, not an already selected scenario.', 2);
+    const campaign = identifier(prefix.split('/').at(-1));
+    const chosen = supplied ?? (interactive ? (await choosePage('Scenario findings', `${prefix}/scenario-findings`, scope, options, row => ({ label: row.name, detail: `Revision ${row.revision}; ${row.retained_trials.toLocaleString()} retained drills` }), value => findingsMatch(value, { campaign, query: options.search ?? '' }))).id : undefined);
+    const params = new URLSearchParams({ page: chosen ? '1' : options.page ?? '1', q: chosen ? '' : options.search ?? '' });
+    if (chosen)
+        params.set('scenario', identifier(chosen));
+    const data = await api(`${prefix}/scenario-findings?${params}`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+    if (!findingsMatch(data, { campaign, query: params.get('q'), scenario: params.get('scenario') ?? undefined }))
+        throw new CliError('report_unavailable', 'These scenario findings could not be confirmed. Reopen the report.');
+    const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+    const reasons = { unmet_checks: 'Unmet checks', agent_error: 'Agent error', timed_out: 'Timed out', execution_error: 'Execution error', checks_met: 'All checks met', assessment_record: 'Assessment available' };
+    output(data, [...data.results.flatMap(row => [row.name, `Revision ${row.revision}; ${row.retained_trials.toLocaleString()} retained drills`,
+            ...Object.entries(row.execution_states).map(([state, count]) => `${state.replaceAll('_', ' ')}: ${count.toLocaleString()}`),
+            ...(row.unclassified_execution ? [`Unrecognized execution status: ${row.unclassified_execution.toLocaleString()} drills`] : []),
+            ...Object.entries(row.checks).map(([state, count]) => `${trialChecks[state] ?? state}: ${count.toLocaleString()}`),
+            `${row.semantic.scored_trials.toLocaleString()} drills with at least one score; ${row.semantic.scored.toLocaleString()} scored assessments; ${row.semantic.not_assessable.toLocaleString()} not assessable; ${row.semantic.not_applicable.toLocaleString()} not applicable`,
+            ...row.examples.map(sample => `Example drill ${sample.trial_position + 1}: ${sample.selected_for.map(kind => reasons[kind] ?? 'Recorded outcome').join(', ')}\n${workspaceLink(scope.workspace, `/campaigns/${prefix.split('/').at(-1)}/trials/${sample.execution_id}${sample.assessment_id ? `?view=assessment&assessment=${sample.assessment_id}` : ''}`)}`),
+            `Scenario revision: ${row.id}`]), `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+        ...(data.pending ? ['More assessments are pending.'] : []),
+        ...(data.next && !chosen ? [`Continue: firedrill report ${campaign} findings --workspace ${scope.workspace} --page ${data.page + 1}${options.search ? ' --search ' + quote(options.search) : ''}${options.json ? ' --json' : ''}`] : []),
+        'Examples are the lowest-numbered available drill for each outcome or assessment, not a random sample. Execution and checks are not semantic scores.'].join('\n'));
+}
+async function scoreReport(supplied, prefix, scope, interactive, options, output) {
+    if (options.checkpoint !== undefined)
+        throw new CliError('arguments_invalid', 'Checkpoint selection applies to memory reports, not score groups.', 2);
+    const auth = { actor: scope.owner, workspace: scope.workspace, signal: options.signal };
+    const number = (value) => value === null ? 'Not assessed' : value.toLocaleString(undefined, { maximumFractionDigits: 2 });
+    const summary = (value, cohort) => [
+        `${value.assessed.toLocaleString()} assessed of ${value.observed.toLocaleString()} retained assessments; ${value.not_assessable.toLocaleString()} not assessable; ${value.not_applicable.toLocaleString()} not applicable`,
+        `Mean: ${number(value.mean)}${value.mean === null ? '' : ` / ${cohort.levels.length - 1}`}; range ${number(value.minimum)} to ${number(value.maximum)}`
+    ];
+    if (!supplied && !interactive) {
+        const data = await api(`${prefix}/assessment-groups?page=${options.page ?? '1'}&q=${encodeURIComponent(options.search ?? '')}`, auth);
+        output(data, [...data.results.flatMap(row => [`${row.cohort.scenario_name}: ${row.cohort.criterion}`, `Evaluator: ${row.cohort.model} (requested ${row.cohort.requested_model})`,
+                ...summary(row.summary, row.cohort), `Cohort assessment: ${row.cohort.assessment_id}`]),
+            `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`].join('\n'));
+        return;
+    }
+    const selected = supplied ?? (await choosePage('Score group', `${prefix}/assessment-groups`, scope, options, row => ({ label: `${row.cohort.scenario_name}: ${row.cohort.criterion}`, detail: `${row.cohort.model}; ${row.summary.assessed.toLocaleString()} assessed` }))).cohort.assessment_id;
+    const params = new URLSearchParams({ page: supplied ? options.page ?? '1' : '1' });
+    if (options.assessmentStatus)
+        params.set('status', scoreStatuses[options.assessmentStatus]);
+    if (options.scoreBucket !== undefined)
+        params.set('bucket', options.scoreBucket);
+    const path = `${prefix}/assessment-groups/${identifier(selected)}/observations`;
+    const readScores = async () => {
+        const value = await api(`${path}?${params}`, auth);
+        if (!scoreCohortMatches(value.cohort, { assessment_id: selected }) || value.filters.status !== (params.get('status') ?? '')
+            || value.filters.bucket !== (params.has('bucket') ? Number(params.get('bucket')) : null))
+            throw new CliError('assessment_cohort_changed', 'The selected score group could not be confirmed.');
+        return value;
+    };
+    let data = await readScores();
+    if (interactive && options.assessmentStatus === undefined && options.scoreBucket === undefined) {
+        const filter = await selectOne('Inspect assessments', [
+            { value: '', label: 'All retained assessments' },
+            ...Object.values(scoreStatuses).map(value => ({ value: `status:${value}`, label: assessmentLabels[value] })),
+            ...data.distribution.map(row => ({ value: `bucket:${row.index}`, label: `Score ${row.minimum} to ${row.upper_inclusive ? '' : 'below '}${row.maximum}`, detail: `${row.count.toLocaleString()} assessed drills` })),
+        ], options.signal);
+        if (filter) {
+            const [key, value] = filter.split(':');
+            params.set(key, value);
+            params.set('page', '1');
+            data = await readScores();
+        }
+    }
+    output(data, [data.cohort.scenario_name, data.cohort.criterion,
+        `Evaluator: ${data.cohort.model} (requested ${data.cohort.requested_model})`,
+        data.cohort.direction === 'lower' ? 'Lower scores are better.' : 'Higher scores are better.',
+        ...summary(data.summary, data.cohort),
+        ...data.cohort.levels.map((label, index) => `${index}. ${label}`),
+        ...data.distribution.map(row => `Interval ${row.index}: ${row.minimum} to ${row.upper_inclusive ? '' : 'below '}${row.maximum}: ${row.count.toLocaleString()} assessed drills`),
+        `${data.count.toLocaleString()} matching assessments`,
+        `Matching drills: firedrill report ${prefix.split('/').at(-1)} drill --workspace ${scope.workspace} --cohort ${identifier(selected)}${params.get('status') ? ' --assessment-status ' + Object.entries(scoreStatuses).find(([, value]) => value === params.get('status'))[0] : ''}${params.has('bucket') ? ' --score-bucket ' + params.get('bucket') : ''} --json`,
+        ...data.results.map(row => `Drill ${row.trial_position + 1}: ${assessmentLabels[row.status] ?? 'Unavailable'}; ${number(row.score)}\n${workspaceLink(scope.workspace, `/campaigns/${prefix.split('/').at(-1)}/trials/${row.execution_id}?view=assessment&assessment=${row.assessment_id}`)}`),
+        `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+        ...(data.pending ? ['More assessments are pending.'] : []),
+        'Intervals describe retained scores, not pass/fail thresholds. Missing evidence is not a zero score.'].join('\n'));
+}
+async function assessmentPreparationReport(trial, prefix, scope, interactive, options, output) {
+    const labels = { queued: 'Queued', preparing: 'Preparing', retrying: 'Retrying', stopped: 'Stopped', finished: 'Preparation finished' };
+    const states = new Set(['issues', ...Object.keys(labels)]);
+    if (options.checkpoint || options.scenario || options.checks || options.origin || options.evidenceKind || options.status && !states.has(options.status))
+        throw new CliError('arguments_invalid', 'Use --status issues|queued|preparing|retrying|stopped|finished with assessment-status. Search finds scenario names.', 2);
+    const path = trial ? `${prefix}/trials/${identifier(trial)}` : prefix;
+    const status = options.status ?? (interactive ? await selectOne('Automatic assessment preparation', [
+        { value: 'issues', label: 'Needs review' }, { value: '', label: 'All preparation' },
+        ...Object.entries(labels).map(([value, label]) => ({ value, label })),
+    ], options.signal) : 'issues');
+    const params = new URLSearchParams({ page: options.page ?? '1', status, q: options.search ?? '' });
+    const data = await api(`${path}/assessment-preparation?${params}`, {
+        actor: scope.owner, workspace: scope.workspace, signal: options.signal
+    });
+    const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+    output(data, [data.results.map(row => `Drill ${row.trial_position + 1}: ${row.scenario_name} · ${labels[row.state] ?? 'Status unavailable'}\n${row.created_at}${row.problem ? '\n' + row.problem : ''}\n${workspaceLink(scope.workspace, `/campaigns/${prefix.split('/').at(-1)}/trials/${row.execution_id}?view=assessment`)}`).join('\n\n') || 'No matching automatic assessment preparation records.',
+        `Page ${data.page}, ${data.count} records.`, ...(data.pending ? ['Automatic assessment preparation is still in progress.'] : []),
+        ...(data.next ? [`Continue: firedrill report ${prefix.split('/').at(-1)} assessment-status${trial ? ' ' + trial : ''} --workspace ${scope.workspace} --page ${data.page + 1}${status ? ' --status ' + status : ''}${options.search ? ' --search ' + quote(options.search) : ''}${options.json ? ' --json' : ''}`] : []),
+        'Preparation status is not an agent result or an evaluator score.'].join('\n'));
+}
+async function assessmentReport(args, prefix, scope, interactive, options, output) {
+    if (options.checkpoint || args[4] && !['policy', 'observation', 'evidence'].includes(args[4])
+        || args[3] && (options.search || options.status || options.origin || options.page && args[4] !== 'evidence')
+        || options.evidenceKind && args[4] !== 'evidence') {
+        throw new CliError('arguments_invalid', 'Use report <campaign> assessments [drill] [assessment] [policy|observation|evidence]. Search/status/origin apply to assessment lists; evidence has its own page and --kind.', 2);
+    }
+    const auth = { actor: scope.owner, workspace: scope.workspace, signal: options.signal };
+    let trial = args[2] ? identifier(args[2]) : undefined;
+    if (!trial && !interactive && (options.status || options.origin))
+        throw new CliError('trial_required', 'Choose a drill ID before filtering its assessment history. No assessment was requested.', 2);
+    if (!trial && !interactive) {
+        const data = await api(`${prefix}/trials?page=${options.page ?? '1'}&q=${encodeURIComponent(options.search ?? '')}`, auth);
+        output(data, data.results.map(row => `Drill ${row.position + 1}: ${row.scenario_name} · ${row.state}\n${row.id}`).join('\n\n') || 'No retained drills.');
+        return;
+    }
+    const chosenTrial = !trial;
+    if (!trial)
+        trial = identifier((await choosePage('Drill assessments', `${prefix}/trials`, scope, options, row => ({ label: `Drill ${row.position + 1}: ${row.scenario_name}`, detail: row.state }))).id);
+    const path = `${prefix}/trials/${trial}`;
+    const search = chosenTrial ? '' : options.search ?? '';
+    const list = new URLSearchParams({ q: search, status: options.status ?? '', origin: options.origin ?? '' });
+    let assessment = args[3] ? identifier(args[3]) : undefined;
+    if (!assessment && !interactive) {
+        const data = await api(`${path}/assessments?${list}&page=${options.page ?? '1'}`, auth);
+        if (!assessmentPageMatches(data, prefix.split('/').at(-1), trial))
+            throw new CliError('assessment_report_changed', 'The selected assessment history could not be confirmed.');
+        const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+        output(data, (data.results.map(row => `${row.name}: ${assessmentLabels[row.state] ?? row.state.replaceAll('_', ' ')}${typeof row.score === 'number' ? ` (${row.score} / ${row.maximum})${row.band ? ' · ' + row.band.label : ''}` : ''}${row.checkpoint ? `\nCheckpoint at turn ${row.checkpoint.turn}. Provisional, excluded from final scores and CI.` : row.partial_execution ? '\nPartial evidence, excluded from final scores and CI.' : ''}\n${row.id}`).join('\n\n') || 'No matching assessments.')
+            + `\nPage ${data.page}, ${data.count} assessments.${data.next ? `\nContinue: firedrill report ${prefix.split('/').at(-1)} assessments ${trial} --workspace ${scope.workspace} --page ${data.page + 1}${search ? ' --search ' + quote(search) : ''}${options.status ? ' --status ' + options.status : ''}${options.origin ? ' --origin ' + options.origin : ''}${options.json ? ' --json' : ''}` : ''}`
+            + (data.automatic_preparation.issue_trials ? `\nAutomatic assessment preparation needs review. Inspect: firedrill report ${prefix.split('/').at(-1)} assessment-status ${trial} --workspace ${scope.workspace}` : ''));
+        return;
+    }
+    if (!assessment)
+        assessment = identifier((await choosePage('Assessment', `${path}/assessments?status=${options.status ?? ''}&origin=${options.origin ?? ''}`, scope, { ...options, page: chosenTrial ? undefined : options.page, search }, row => ({ label: row.name,
+            detail: `${assessmentLabels[row.state] ?? row.state.replaceAll('_', ' ')}${row.score === null ? '' : ` · ${row.score} / ${row.maximum}`}${row.checkpoint ? ' · Provisional checkpoint' : row.partial_execution ? ' · Partial evidence' : ''}` }))).id);
+    const row = await api(`${path}/assessments/${assessment}`, auth);
+    if (!assessmentMatches(row, prefix.split('/').at(-1), trial, assessment))
+        throw new CliError('assessment_report_changed', 'The selected assessment could not be confirmed. No evaluation was repeated.');
+    output(row, [`${row.name} · ${row.state.replaceAll('_', ' ')}`,
+        typeof row.result?.score === 'number' ? `Score: ${row.result.score} / ${row.result.levels.length - 1}. ${row.rubric.direction === 'lower' ? 'Lower' : 'Higher'} is better.` : 'No numeric score recorded.',
+        `${row.provider} · ${row.model ?? 'Requested ' + row.requested_model}`,
+        ...(row.checkpoint ? [`Checkpoint at turn ${row.checkpoint.turn}, ${row.checkpoint.observed_at}. Provisional, excluded from final scores and CI.`]
+            : row.partial_execution ? ['Assessed from partial evidence, excluded from final scores and CI.'] : []),
+        ...(row.problem ? [row.problem] : []), ...(row.result?.company_policies ?? []).map(policy => `${policy.name} · Version ${policy.version}`),
+        ...(row.result?.explanation ? [`Evidence explanation: ${row.result.explanation.state.replaceAll('_', ' ')}`,
+            ...(row.result.explanation.state === 'succeeded' ? [`Explanation, linked to the saved evidence.`,
+                ...row.result.explanation.observations.flatMap(item => [item.text,
+                    ...item.evidence.map(ref => `${ref.kind}${ref.kind === 'state' || ref.position === null ? '' : ` · Position ${ref.position + 1}`} · ${ref.id}\n${ref.quote}\nInspect: firedrill report ${prefix.split('/').at(-1)} drill ${trial} ${ref.kind === 'state' ? 'state checkpoints' : ref.kind === 'message' ? 'messages' : 'actions'} ${ref.id} --workspace ${scope.workspace}`),
+                    ...item.policies.map(ref => `Policy ${ref.revision_id} · ${ref.paragraph_id}\n${ref.quote}`)]), row.result.explanation.limitation]
+                : [row.result.explanation.problem || 'The cited explanation is pending. Reading this report does not repeat evaluation.'])] : []),
+        row.rubric.instructions ?? '', ...((row.rubric.levels ?? []).map((level, index) => `${index}. ${level}`)),
+        workspaceLink(scope.workspace, `/campaigns/${args[0] ?? prefix.split('/').at(-1)}/trials/${trial}?view=assessment&assessment=${assessment}`)].filter(Boolean).join('\n'));
+    const support = row.result?.policy_support;
+    let inspect = args[4];
+    if (!inspect && interactive && (support?.policy || support?.observation || row.evidence_count))
+        inspect = await selectOne('Inspect supporting evidence', [
+            { value: 'done', label: 'Done' }, ...(support?.policy ? [{ value: 'policy', label: 'Policy passage' }] : []),
+            ...(support?.observation ? [{ value: 'observation', label: support.observation.kind === 'state' ? 'Observed service state' : 'Recorded message or tool action' }] : []),
+            ...(row.evidence_count ? [{ value: 'evidence', label: 'Evidence files' }] : [])
+        ], options.signal);
+    if (inspect === 'policy') {
+        const selected = support?.policy;
+        if (!selected || !/^p[0-9]{1,11}$/.test(selected.paragraph_id))
+            throw new CliError('assessment_anchor_unavailable', 'No available supporting policy passage was retained.');
+        const data = await api(`/api/workspaces/${scope.workspace}/agents/${identifier(row.agent_id)}/policies/${identifier(selected.revision_id)}/paragraphs/${selected.paragraph_id}`, auth);
+        if (data.policy.id !== selected.revision_id || data.policy.agent_id !== row.agent_id || data.paragraph.id !== selected.paragraph_id)
+            throw new CliError('assessment_anchor_changed', 'The original policy passage could not be confirmed.');
+        output(data, `${data.policy.name} · Version ${data.policy.version}\n${data.paragraph.id}${data.paragraph.page ? ` · Page ${data.paragraph.page}` : ''}\n${data.paragraph.text}`);
+    }
+    else if (inspect === 'observation') {
+        const selected = support?.observation;
+        if (!selected || !['message', 'action', 'state'].includes(selected.kind))
+            throw new CliError('assessment_anchor_unavailable', 'No available supporting drill observation was retained.');
+        const data = await api(`${path}/${selected.kind === 'state' ? 'state-comparisons/checkpoints' : selected.kind === 'message' ? 'messages' : 'actions'}/${identifier(selected.id)}`, auth);
+        if (!assessmentEvidenceMatches(data, selected))
+            throw new CliError('assessment_anchor_changed', 'The original supporting observation could not be confirmed.');
+        output(data, 'sequence' in data ? `${checkpointLabel(data)} · ${data.status}\nInspect: firedrill report ${prefix.split('/').at(-1)} drill ${trial} state checkpoints ${data.id} --workspace ${scope.workspace}` : JSON.stringify(data, null, 2));
+    }
+    else if (inspect === 'evidence') {
+        const data = await api(`${path}/assessments/${assessment}/evidence?page=${options.page ?? '1'}&kind=${options.evidenceKind ?? ''}`, auth);
+        output(data, (data.results.map(file => `${file.kind === 'transcript' ? 'Conversation' : file.kind === 'state_snapshot' ? 'Observed service state' : 'Tool actions'} · ${file.size} bytes · ${file.created_at}\n${file.id}\n${APP_ORIGIN}${path}/files/${file.id}/download`).join('\n\n') || 'No matching assessment evidence files.')
+            + `\nPage ${data.page}, ${data.count} files.${data.next ? `\nContinue: firedrill report ${prefix.split('/').at(-1)} assessments ${trial} ${assessment} evidence --workspace ${scope.workspace} --page ${data.page + 1}${options.evidenceKind ? ' --kind ' + options.evidenceKind : ''}${options.json ? ' --json' : ''}` : ''}`);
+    }
+}
+export async function reportCommand(args, options, output) {
+    // Keep retained API/type identities stable while the terminal uses Drill.
+    args = args.map((value, index) => index === 1 && value === 'drill' ? 'trial'
+        : index === 5 && value === 'drills' ? 'trials' : value);
+    const interactive = !options.json && !!process.stdin.isTTY && !!process.stderr.isTTY;
+    if ([options.evidenceAttempt, options.evidenceStep, options.evidenceFrom, options.evidenceTo].some(value => value !== undefined)
+        && !(args[1] === 'trial' && args[2] && ['evidence', 'timeline'].includes(args[3])))
+        throw new CliError('arguments_invalid', 'Use evidence filters only with report <campaign> drill <drill> evidence or timeline.', 2);
+    if (args[1] === 'trial' && args[2] && args[3] === 'world-events') {
+        if ([options.checkpoint, options.scenario, options.checks, options.cohort, options.origin,
+            options.serviceRequest, options.scoreBucket, options.assessmentStatus, options.evaluator,
+            options.checkMethod, options.side, options.evidenceKind, options.into].some(value => value !== undefined) || options.approveDownload)
+            throw new CliError('arguments_invalid', 'Use report <campaign> drill <drill> world-events with page, search or event status only.', 2);
+        const scope = await selectedWorkspace({ workspace: options.workspace, interactive, openBrowser: options.openBrowser, signal: options.signal });
+        await campaignWorldCommand(args.slice(4), `/api/workspaces/${scope.workspace}/campaigns/${identifier(args[0])}/trials/${identifier(args[2])}`, scope, options, output);
+        return;
+    }
+    if (options.file !== undefined || options.change !== undefined)
+        throw new CliError('arguments_invalid', 'Use --file and --approve-change only with drill world-events controls.', 2);
+    if (args[1] === 'trial' && args[2] && ['evidence', 'timeline'].includes(args[3])) {
+        if (args.length > 5 || !args[0] || options.search !== undefined || options.checkpoint !== undefined || options.status !== undefined
+            || options.scenario !== undefined || options.checks !== undefined || options.cohort !== undefined || options.origin !== undefined
+            || options.requestKey !== undefined || options.serviceRequest !== undefined || options.scoreBucket !== undefined || options.assessmentStatus !== undefined
+            || options.evaluator !== undefined || options.checkMethod !== undefined || options.side !== undefined
+            || options.page !== undefined && !/^[1-9][0-9]{0,8}$/.test(options.page))
+            throw new CliError('arguments_invalid', 'Use report <campaign> drill <drill> evidence [artifact] or timeline [driver-step]. --kind filters evidence or observation type; --into and --approve-download apply to evidence.', 2);
+        const scope = await selectedWorkspace({ workspace: options.workspace, interactive, openBrowser: options.openBrowser, signal: options.signal });
+        const execution = identifier(args[2]);
+        const path = `/api/workspaces/${scope.workspace}/campaigns/${identifier(args[0])}/trials/${execution}`;
+        if (args[3] === 'evidence')
+            await evidenceCommand(path, execution, args[4], scope, interactive, options, output);
+        else
+            await timelineCommand(path, execution, args[4], scope, options, output);
+        return;
+    }
+    const stateInspection = args[1] === 'trial' && Boolean(args[2]) && args[3] === 'state';
+    const nativeCheckView = args[1] === 'checks' || args[1] === 'compare' && args[3] === 'checks';
+    const compositeView = args[1] === 'compare' && args[3] === 'composite';
+    if (options.evaluator !== undefined && (!compositeView || !options.evaluator.length || options.evaluator.length > 128 || /[\u0000-\u001f\u007f]/.test(options.evaluator)))
+        throw new CliError('arguments_invalid', 'Use --evaluator <version|unavailable> with composite comparison drills.', 2);
+    if (options.checkMethod !== undefined && (!nativeCheckView || !['', 'exact', 'semantic', 'both', 'unknown'].includes(options.checkMethod)))
+        throw new CliError('arguments_invalid', 'Use --method exact|semantic|both|unknown with a recorded-check group list.', 2);
+    if (options.side !== undefined && (!['compare', 'checks'].includes(args[1]) || !['current', 'baseline', 'both'].includes(options.side)))
+        throw new CliError('arguments_invalid', 'Use --side current|baseline|both with selected check or comparison observations.', 2);
+    if (stateInspection)
+        validateTrialStateOptions(args.slice(4), options);
+    if (args[1] === 'trial' && args[3] && !['messages', 'actions', 'requests', 'checks', 'check-observation', 'coverage', 'state', 'schedule', 'captures', 'desktop-captures', 'recordings', 'clips'].includes(args[3]))
+        throw new CliError('arguments_invalid', 'Choose messages, actions, requests, checks, check-observation, coverage, state, schedule, captures, desktop-captures, recordings or clips from the drill report.', 2);
+    if (options.serviceRequest !== undefined) {
+        if (args[1] !== 'trial' || !args[2] || args[3] !== 'actions' || args[4] || options.checkpoint !== undefined
+            || options.scenario !== undefined || options.checks !== undefined)
+            throw new CliError('arguments_invalid', 'Use --service-request <receipt-id> with report <campaign> drill <drill> actions.', 2);
+        validateActionOptions(options);
+    }
+    if (args[1] === 'export') {
+        validateExport(args.slice(2), options);
+        if (options.checkpoint !== undefined)
+            throw new CliError('arguments_invalid', 'Checkpoint selection does not apply to report exports.', 2);
+    }
+    else if (options.requestKey !== undefined || options.into !== undefined || options.approveDownload !== undefined) {
+        throw new CliError('arguments_invalid', 'Use export request and download options with report <campaign> export.', 2);
+    }
+    if (options.cohort !== undefined) {
+        if (!(args[1] === 'trial' && !args[2] || args[1] === 'export' && args[2] === 'create') || options.checkpoint !== undefined)
+            throw new CliError('arguments_invalid', 'Use --cohort <assessment> with a drill list or export create.', 2);
+        identifier(options.cohort);
+    }
+    if (options.scoreBucket !== undefined || options.assessmentStatus !== undefined) {
+        if (!(args[1] === 'scores' && args[2] || (args[1] === 'trial' && !args[2] || args[1] === 'export' && args[2] === 'create') && options.cohort) || options.checkpoint !== undefined
+            || options.scoreBucket !== undefined && !/^[0-8]$/.test(options.scoreBucket)
+            || options.assessmentStatus !== undefined && !Object.hasOwn(scoreStatuses, options.assessmentStatus)
+            || options.scoreBucket !== undefined && options.assessmentStatus !== undefined && options.assessmentStatus !== 'assessed') {
+            throw new CliError('arguments_invalid', 'Use score filters with scores <cohort-assessment>, drill --cohort <assessment>, or export create --cohort <assessment>. A score interval applies only to assessed drills.', 2);
+        }
+    }
+    if (options.scenario !== undefined || options.status !== undefined || options.checks !== undefined) {
+        const requestList = args[1] === 'trial' && !!args[2] && args[3] === 'requests' && !args[4]
+            && options.scenario === undefined && options.checks === undefined;
+        const actionList = args[1] === 'trial' && !!args[2] && args[3] === 'actions' && !args[4]
+            && options.scenario === undefined && options.checks === undefined;
+        const checkList = args[1] === 'trial' && !!args[2] && args[3] === 'checks' && !args[4]
+            && options.scenario === undefined && options.checks === undefined;
+        const preparationList = args[1] === 'assessment-status' && args.length <= 3 && options.scenario === undefined && options.checks === undefined;
+        const assessmentList = args[1] === 'assessments' && !args[3] && options.scenario === undefined && options.checks === undefined;
+        const stateEvents = stateInspection && args[5] === 'events' && options.scenario === undefined && options.checks === undefined;
+        const nativeCheckFilter = nativeCheckView && options.scenario === undefined && options.checks === undefined;
+        const compositeFilter = compositeView && options.scenario === undefined && options.checks === undefined;
+        if (!(actionList || requestList || checkList || nativeCheckFilter || compositeFilter || stateEvents || assessmentList || preparationList || args[1] === 'assignments' && !args[2] || args[1] === 'trial' && !args[2] || args[1] === 'export' && args[2] === 'create') || options.checkpoint !== undefined)
+            throw new CliError('arguments_invalid', 'Use status with report observation lists, or execution/scenario/check filters with drill lists, assignments and export create.', 2);
+        if (options.scenario)
+            identifier(options.scenario);
+        if (requestList)
+            validateReceiptOptions(options);
+        if (actionList)
+            validateActionOptions(options);
+        if (checkList)
+            validateCheckOptions(options);
+        if (nativeCheckFilter && options.status && !['met', 'unmet', 'unconfirmed'].includes(options.status))
+            throw new CliError('arguments_invalid', 'Choose met, unmet or unconfirmed recorded checks.', 2);
+        if (compositeFilter && options.status !== undefined && !['all', 'available', 'unavailable'].includes(options.status))
+            throw new CliError('arguments_invalid', 'Choose all, available or unavailable composite drill indices.', 2);
+        if (options.status && !actionList && !requestList && !checkList && !nativeCheckFilter && !compositeFilter && !stateEvents && !preparationList && !(assessmentList ? assessmentStates : trialStates).has(options.status) || options.checks && !Object.hasOwn(trialChecks, options.checks)) {
+            throw new CliError('arguments_invalid', 'Choose a recorded execution status and met, unmet, unassessed, unavailable or missing checks.', 2);
+        }
+    }
+    if (options.origin !== undefined && (args[1] !== 'assessments' || args[3] || !['manual', 'automatic'].includes(options.origin)))
+        throw new CliError('arguments_invalid', 'Use --origin manual|automatic with an assessment list.', 2);
+    if (options.evidenceKind !== undefined) {
+        if (stateInspection)
+            validateTrialStateOptions(args.slice(4), options);
+        else if (args[1] === 'trial' && args[2] && args[3] === 'checks' && !args[4])
+            validateCheckOptions(options);
+        else if (args[1] !== 'assessments' || args[4] !== 'evidence' || !['transcript', 'tool_trace', 'state_snapshot'].includes(options.evidenceKind))
+            throw new CliError('arguments_invalid', 'Use --kind with assessment evidence, a drill recorded-check list or observed state changes.', 2);
+    }
+    if (args.length > (['export', 'activity'].includes(args[1]) ? 4 : args[1] === 'compare' ? args[3] === 'composite' ? 6 : 5 : stateInspection ? 8 : args[1] === 'trial' && args[3] === 'schedule' ? 6 : ['assessments', 'trial'].includes(args[1]) ? 5 : 3) || args[1] && !['memory', 'composite', 'compare', 'style', 'usage', 'checks', 'assessments', 'assessment-status', 'trial', 'scores', 'findings', 'export', 'assignments', 'activity', 'insights'].includes(args[1]) || args[2] && !['memory', 'composite', 'compare', 'style', 'usage', 'checks', 'assessments', 'assessment-status', 'trial', 'scores', 'findings', 'export', 'activity'].includes(args[1])
+        || options.page !== undefined && !/^[1-9][0-9]{0,8}$/.test(options.page) || (options.search?.length ?? 0) > 200
+        || options.checkpoint !== undefined && !/^[a-z][a-z0-9_]{0,47}$/.test(options.checkpoint)) {
+        throw new CliError('arguments_invalid', 'Choose a report: drill, assignments, activity, insights, findings, checks, scores, assessments, memory, style, usage, composite, compare or export. Run firedrill report interactively for guided selection.', 2);
+    }
+    if (args[1] === 'activity' && (options.page !== undefined || options.checkpoint !== undefined
+        || /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/.test(options.search ?? '')
+        || !/^[0-9]{1,19}$/.test(args[2] ?? '0') || BigInt(args[2] ?? '0') > 9223372036854775807n
+        || args[3] !== undefined && !/^[a-z][a-z0-9_.]{0,63}$/.test(args[3]))) {
+        throw new CliError('arguments_invalid', 'Use report <campaign> activity [before-sequence] [activity-type] with optional --search for recorded services or operations. Omit the cursor for latest activity.', 2);
+    }
+    if (args[1] === 'scores') {
+        if (options.checkpoint !== undefined || args[2] && options.search)
+            throw new CliError('arguments_invalid', 'Search applies to score groups. Use a cohort assessment ID to inspect its observations, without a checkpoint.', 2);
+        if (args[2])
+            identifier(args[2]);
+    }
+    if (args[1] === 'findings') {
+        if (options.checkpoint !== undefined || args[2] && (options.search || options.page))
+            throw new CliError('arguments_invalid', 'Search and paging apply to the scenario directory, not one selected scenario. Checkpoints do not apply to findings.', 2);
+        if (args[2])
+            identifier(args[2]);
+    }
+    let campaign = args[0] ? identifier(args[0]) : undefined;
+    if (!campaign && !interactive)
+        throw new CliError('campaign_required', 'Pass a saved campaign ID. Use firedrill simulations --json to find it.', 2);
+    const scope = await selectedWorkspace({ workspace: options.workspace, interactive, openBrowser: options.openBrowser, signal: options.signal });
+    if (!campaign) {
+        const selected = await choosePage('Simulation report', `/api/workspaces/${scope.workspace}/simulations`, scope, options, row => ({ label: row.name, detail: row.status }));
+        campaign = identifier(selected.campaign_id);
+    }
+    const prefix = `/api/workspaces/${scope.workspace}/campaigns/${campaign}`;
+    const mode = args[1] ?? (interactive ? await selectOne('Report', [{ value: 'summary', label: 'Summary' },
+        { value: 'insights', label: 'Retained recommendations' },
+        { value: 'trial', label: 'Drill details and input/output' },
+        { value: 'assignments', label: 'Current execution slots' },
+        { value: 'activity', label: 'Latest activity and completions' },
+        { value: 'assessments', label: 'Evidence-based assessments' },
+        { value: 'assessment-status', label: 'Automatic assessment preparation' },
+        { value: 'scores', label: 'Score distributions and drills' },
+        { value: 'findings', label: 'Scenario findings and example drills' },
+        { value: 'checks', label: 'Recorded checks' }, { value: 'memory', label: 'Memory checkpoints' }, { value: 'style', label: 'Style observations' }, { value: 'usage', label: 'Target model usage' },
+        { value: 'composite', label: 'Composite indices' }, { value: 'compare', label: 'Compare saved simulations' },
+        { value: 'export', label: 'Saved report exports' }], options.signal) : 'summary');
+    if (mode === 'export') {
+        await reportExport(args.slice(2), prefix, scope, interactive, options, output);
+        return;
+    }
+    if (mode === 'trial') {
+        await trialReport(args, prefix, scope, interactive, options, output);
+        return;
+    }
+    if (mode === 'insights') {
+        if (options.page !== undefined || options.search !== undefined || options.checkpoint !== undefined)
+            throw new CliError('arguments_invalid', 'Insights reads the retained review only. Paging and checkpoint options do not apply.', 2);
+        const value = await api(`${prefix}/insights`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+        if (!insightsMatch(value, campaign))
+            throw new CliError('report_unavailable', 'These retained recommendations could not be confirmed. Reopen the report.');
+        output(value, [`Review: ${value.state.replaceAll('_', ' ')}`, value.content, value.problem,
+            value.state === 'unavailable' && !value.problem ? 'No retained recommendations are available. Execution results remain in the summary.' : '',
+            value.proposal_count ? `${value.proposal_count} retained recommendations.` : '',
+            workspaceLink(scope.workspace, `/campaigns/${campaign}?view=insights`)].filter(Boolean).join('\n\n'));
+        return;
+    }
+    if (mode === 'assignments') {
+        if (options.checkpoint !== undefined)
+            throw new CliError('arguments_invalid', 'Checkpoint selection does not apply to current execution slots.', 2);
+        if (/[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/.test(options.search ?? ''))
+            throw new CliError('arguments_invalid', 'Use search text without terminal control characters.', 2);
+        const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+        const filters = new URLSearchParams({ page: options.page ?? '1', q: options.search ?? '' });
+        if (options.status)
+            filters.set('status', options.status);
+        if (options.checks)
+            filters.set('checks', options.checks);
+        if (options.scenario)
+            filters.set('scenario', identifier(options.scenario));
+        const value = await api(`${prefix}/assignments?${filters}`, { actor: scope.owner, signal: options.signal });
+        if (value.campaign_id !== campaign)
+            throw new CliError('campaign_changed', 'The simulation could not be confirmed. Open it again.', 2);
+        output(value, [(value.results.map(row => `Drill ${(row.position + 1).toLocaleString()}: ${row.scenario_name}\n${executionPhase(row.phase)}${row.attempt_number !== null && row.attempt_number > 1 ? ` · Attempt ${row.attempt_number}` : ''}\n${workspaceLink(scope.workspace, `/campaigns/${campaign}/trials/${row.execution_id}`)}`).join('\n\n') || 'No execution slots are currently assigned for these filters.'),
+            `Page ${value.page}, ${value.count.toLocaleString()} matching assignments. Assignment is not proof of agent invocation or a successful outcome.`,
+            ...(value.next ? [`Continue: firedrill report ${campaign} assignments --workspace ${scope.workspace} --page ${value.page + 1}${options.search ? ' --search ' + quote(options.search) : ''}${options.status ? ' --status ' + options.status : ''}${options.checks ? ' --checks ' + options.checks : ''}${options.scenario ? ' --scenario ' + identifier(options.scenario) : ''} --json`] : [])].join('\n\n'));
+        return;
+    }
+    if (mode === 'activity') {
+        if (options.page !== undefined || options.checkpoint !== undefined)
+            throw new CliError('arguments_invalid', 'Activity uses the retained sequence cursor, not page or checkpoint options.', 2);
+        const kind = args[3] ?? '', cursor = args[2] ?? '0', search = (options.search ?? '').trim();
+        const value = await api(`${prefix}/events?${new URLSearchParams({ before: cursor, kind, q: search })}`, { actor: scope.owner, signal: options.signal });
+        if (value.campaign_id !== campaign || value.direction !== 'older' || value.kind !== kind || value.q !== search || !/^[0-9]{1,19}$/.test(value.next_cursor))
+            throw new CliError('campaign_activity_changed', 'The saved activity could not be confirmed. Open it again.', 2);
+        const quote = (input) => `'${input.replaceAll("'", "'\\''")}'`;
+        output(value, [(value.results.map(row => `${row.created_at}: ${activityLabel(row.kind)}${typeof row.content.service_key === 'string' && row.content.service_key ? ` · ${row.content.service_key}` : ''}${typeof row.content.operation === 'string' && row.content.operation ? ` · ${row.content.operation}` : ''}${typeof row.content.http_status === 'number' ? ` · HTTP ${row.content.http_status}` : ''}${row.execution_id ? `\n${workspaceLink(scope.workspace, `/campaigns/${campaign}/trials/${row.execution_id}${row.kind.startsWith('dependency.') ? '?view=requests' : ''}`)}` : ''}`).join('\n\n') || 'No matching activity retained.'),
+            ...(value.has_more ? [`Older: firedrill report ${campaign} activity ${value.next_cursor}${kind ? ' ' + kind : ''} --workspace ${scope.workspace}${search ? ' --search ' + quote(search) : ''} --json`] : [])].join('\n\n'));
+        return;
+    }
+    if (mode === 'assessments') {
+        await assessmentReport(args, prefix, scope, interactive, options, output);
+        return;
+    }
+    if (mode === 'assessment-status') {
+        await assessmentPreparationReport(args[2], prefix, scope, interactive, options, output);
+        return;
+    }
+    if (mode === 'scores') {
+        await scoreReport(args[2], prefix, scope, interactive, options, output);
+        return;
+    }
+    if (mode === 'findings') {
+        await findingsReport(args[2], prefix, scope, interactive, options, output);
+        return;
+    }
+    if (mode === 'compare') {
+        await comparisonCommand(args, prefix, scope, interactive, options, output);
+        return;
+    }
+    if (mode === 'checks') {
+        await nativeCheckCommand(prefix, scope, interactive, options, output, args[2]);
+        return;
+    }
+    if (mode === 'style' || mode === 'usage') {
+        if (options.checkpoint)
+            throw new CliError('arguments_invalid', 'Checkpoint selection applies only to memory reports.', 2);
+        if (mode === 'usage') {
+            if ((options.search?.length ?? 0) > 128)
+                throw new CliError('arguments_invalid', 'Use a model search of up to 128 characters.', 2);
+            const execution = args[2] ? identifier(args[2]) : undefined;
+            const query = new URLSearchParams({ page: options.page ?? '1', model: options.search ?? '' });
+            const data = await api(`${prefix}${execution ? `/trials/${execution}` : ''}/target-usage?${query}`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+            if (!targetUsageMatches(data, campaign, execution, options.search ?? ''))
+                throw new CliError('report_unavailable', 'These target-model records could not be confirmed. Reopen the report.');
+            const count = (value) => typeof value === 'string' && /^[0-9]+$/.test(value) ? BigInt(value).toLocaleString() : 'Not reported';
+            const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+            output(data, [`${data.summary.requests.toLocaleString()} target-model request records`,
+                `Completed: ${data.summary.completed}; failed: ${data.summary.failed}; interrupted: ${data.summary.interrupted}; unfinished: ${data.summary.pending}`,
+                ...['input_tokens', 'output_tokens', 'cache_creation_input_tokens', 'cache_read_input_tokens'].map(key => `${key.replaceAll('_', ' ')}: ${count(data.summary[key])} (${data.summary[`${key}_coverage`]} requests)`),
+                `Mean relay elapsed: ${data.summary.mean_elapsed_ms === null ? 'Not measured' : `${data.summary.mean_elapsed_ms}ms`}`,
+                ...data.results.map(row => `Drill ${row.trial_position + 1}: ${row.requested_model}; ${row.provider}; ${row.operation}; ${row.state.replaceAll('_', ' ')}; input ${count(row.usage.input_tokens)}; output ${count(row.usage.output_tokens)}\n${targetCompletionNotes(row).join(' ')}\n${workspaceLink(scope.workspace, `/campaigns/${campaign}/trials/${row.execution_id}`)}`),
+                `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+                ...(data.next ? [`Continue: firedrill report ${campaign} usage${execution ? ' ' + execution : ''} --workspace ${scope.workspace} --page ${data.page + 1}${options.search ? ' --search ' + quote(options.search) : ''}${options.json ? ' --json' : ''}`] : []),
+                'Provider-reported target usage only, not Firedrill preparation/evaluation spend or billed dollar cost. Relay elapsed includes network handling.'].join('\n'));
+            return;
+        }
+        let assessment = args[2] ? identifier(args[2]) : undefined;
+        if (!assessment && !interactive) {
+            const data = await api(`${prefix}/style-groups?page=${options.page ?? '1'}&q=${encodeURIComponent(options.search ?? '')}`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+            output(data, [...data.results.flatMap(row => [`${row.cohort.scenario_name}: ${row.cohort.criterion} (${row.cohort.assessment_id})`,
+                    `${row.summary.occurrences === null ? 'Unmeasured' : row.summary.occurrences.toLocaleString()} occurrences; ${row.summary.assessed} observed of ${row.summary.observed} retained drills; ${row.summary.partial} partial`]),
+                'Selected style measurements, not semantic quality or an AI-authorship probability.'].join('\n'));
+            return;
+        }
+        const picked = !assessment;
+        if (!assessment)
+            assessment = identifier((await choosePage('Style observations', `${prefix}/style-groups`, scope, options, row => ({ label: row.cohort.scenario_name, detail: row.cohort.criterion }))).cohort.assessment_id);
+        else if (options.search)
+            throw new CliError('arguments_invalid', 'Search applies to style groups, not an already selected group.', 2);
+        const data = await api(`${prefix}/style-groups/${assessment}/observations?page=${picked ? '1' : options.page ?? '1'}`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+        if (!styleCohortMatches(data.cohort, { assessment_id: assessment }))
+            throw new CliError('assessment_cohort_changed', 'The selected style group could not be confirmed.');
+        output(data, [...data.results.map(row => `Drill ${row.trial_position + 1}: ${row.status.replaceAll('_', ' ')}; ${row.count === null ? 'Unmeasured' : `${row.count.toLocaleString()} occurrences`}\n${workspaceLink(scope.workspace, `/campaigns/${campaign}/trials/${row.execution_id}?view=assessment&assessment=${row.assessment_id}`)}`),
+            `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`].join('\n'));
+        return;
+    }
+    if (mode === 'summary') {
+        if (options.checkpoint || args[0] && (options.page || options.search))
+            throw new CliError('arguments_invalid', 'Choose a detailed report before using report paging. Checkpoints apply to memory reports.', 2);
+        const data = await api(`${prefix}/report`, { actor: scope.owner, signal: options.signal });
+        if (data.campaign_id !== campaign)
+            throw new CliError('campaign_report_unavailable', 'This retained report could not be confirmed. Reopen the campaign.');
+        output(data, [`Simulation ${data.campaign_id}`, data.state.replaceAll('_', ' '),
+            ...(data.external_effects ? [`${data.external_effects.real_connections_count} real-account connections. External state is shared across drills and is not reset; other drills and account activity can affect results.`] : []),
+            ...(data.starting_data ? [`${data.starting_data.edit_count} saved edits selected for each independent drill. Inspect each drill for actual application.`] : []),
+            ...(data.application_continuation ? [`Saved starting state: ${data.application_continuation.scope === 'supported_application_and_native_state'
+                    ? 'application and supported synthetic service data' : 'application state with fresh synthetic services'}. ${data.application_continuation.component_count} application components. New process, current wall time; inspect each drill for restoration evidence.`] : []),
+            `${data.retained_trials.toLocaleString()} of ${data.planned_trials.toLocaleString()} drills retained`,
+            ...Object.entries(data.execution_states).map(([state, count]) => `${state.replaceAll('_', ' ')}: ${count.toLocaleString()}`),
+            `Drills with all checks met: ${data.recorded_checks.met.toLocaleString()}; with unmet checks: ${data.recorded_checks.unmet.toLocaleString()}`,
+            `Drill check outcomes unassessed: ${data.recorded_checks.unassessed.toLocaleString()}; unavailable: ${data.recorded_checks.unavailable.toLocaleString()}`,
+            `Elapsed: ${duration(data.timing.wall_elapsed_ms)}`, `Measured drill work: ${duration(data.timing.trial_work_ms)}`,
+            `Report: ${workspaceLink(scope.workspace, `/campaigns/${campaign}`)}`].join('\n'));
+        return;
+    }
+    if (mode === 'composite') {
+        if (options.checkpoint !== undefined)
+            throw new CliError('arguments_invalid', 'Checkpoint selection applies to memory reports.', 2);
+        let execution = args[2] ? identifier(args[2]) : undefined;
+        if (execution && (options.page || options.search))
+            throw new CliError('arguments_invalid', 'Paging and search apply to the drill list, not one composite.', 2);
+        if (!execution && !interactive) {
+            const data = await api(`${prefix}/composites?page=${options.page ?? '1'}&q=${encodeURIComponent(options.search ?? '')}`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+            if (!compositePageMatches(data, campaign))
+                throw new CliError('report_unavailable', 'These saved drill indices could not be confirmed. Reopen the report.');
+            const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+            output(data, [data.results.map(row => `Drill ${row.trial_position + 1}: ${row.value === null ? 'Unavailable' : `${row.value.toLocaleString(undefined, { maximumFractionDigits: 2 })} / 100`}\n${row.execution_id}  ${row.scenario_name}`).join('\n') || 'No matching composite drills.',
+                `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+                ...(data.next ? [`Continue: firedrill report ${campaign} composite --workspace ${scope.workspace} --page ${data.page + 1}${options.search ? ' --search ' + quote(options.search) : ''}${options.json ? ' --json' : ''}`] : [])].join('\n'));
+            return;
+        }
+        if (!execution)
+            execution = identifier((await choosePage('Composite drill', `${prefix}/composites`, scope, options, row => ({ label: `Drill ${row.trial_position + 1}: ${row.scenario_name}`, detail: row.value === null ? 'Index unavailable' : `Index ${row.value.toLocaleString(undefined, { maximumFractionDigits: 2 })} / 100` }), value => compositePageMatches(value, campaign))).execution_id);
+        const data = await api(`${prefix}/trials/${execution}/composite`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+        if (!compositeMatches(data, campaign, execution))
+            throw new CliError('report_unavailable', 'This drill index could not be confirmed. Reopen the report.');
+        output(data, [`Drill ${data.trial_position + 1}: ${data.scenario_name}`,
+            `Composite index: ${data.value === null ? 'Unavailable' : `${data.value.toLocaleString(undefined, { maximumFractionDigits: 2 })} / 100`}`,
+            data.state.replaceAll('_', ' '), ...data.dimensions.map(row => `${row.name}: ${row.status.replaceAll('_', ' ')}; weight ${row.weight}; mapped value ${row.mapped_value === null ? 'Not assessed' : row.mapped_value.toLocaleString(undefined, { maximumFractionDigits: 2 })}`),
+            ...data.required_checks.map(row => `${row.name}: ${row.state}`), 'Weighted index, not a probability or a CI result.',
+            `Report: ${workspaceLink(scope.workspace, `/campaigns/${campaign}/trials/${execution}?view=assessment`)}`].join('\n'));
+        return;
+    }
+    let assessment = args[2] ? identifier(args[2]) : undefined;
+    const selectedInteractively = !assessment && interactive;
+    if (!assessment && !interactive) {
+        if (options.checkpoint)
+            throw new CliError('assessment_required', 'Choose an assessment_id from the memory groups before choosing a checkpoint.', 2);
+        const data = await api(`${prefix}/memory-groups?page=${options.page ?? '1'}&q=${encodeURIComponent(options.search ?? '')}`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+        output(data, data.results.map(row => `${row.assessment_id}  ${row.scenario_name}  ${row.criterion}`).join('\n') || 'No matching memory assessments.');
+        return;
+    }
+    if (!assessment)
+        assessment = identifier((await choosePage('Memory assessment', `${prefix}/memory-groups`, scope, options, row => ({ label: row.scenario_name, detail: `${row.criterion} · ${row.model}` }))).assessment_id);
+    else if (options.search)
+        throw new CliError('arguments_invalid', 'Search applies to the memory group list, not an already selected group.', 2);
+    const page = selectedInteractively ? '1' : options.page ?? '1';
+    const path = `${prefix}/memory-groups/${assessment}/checkpoints`;
+    let index = 0;
+    const readCheckpoint = async (index) => {
+        const value = await api(`${path}?probe=${index}&page=${page}`, { actor: scope.owner, workspace: scope.workspace, signal: options.signal });
+        if (!checkpointMatches(value, assessment, index))
+            throw new CliError('assessment_checkpoint_changed', 'The selected memory checkpoint could not be confirmed.');
+        return value;
+    };
+    let data = await readCheckpoint(0);
+    if (options.checkpoint) {
+        index = data.cohort.memory.probes.findIndex(probe => probe.key === options.checkpoint);
+        if (index < 0)
+            throw new CliError('checkpoint_unavailable', 'This frozen criterion does not contain that checkpoint.', 2);
+    }
+    else if (interactive)
+        index = await selectOne('Checkpoint', data.cohort.memory.probes.map((probe, value) => ({ value,
+            label: `${memoryCheckpointLabel(probe)}: ${probe.key.replaceAll('_', ' ')}`, detail: probe.expectation })), options.signal);
+    if (index !== 0)
+        data = await readCheckpoint(index);
+    output(data, [data.cohort.scenario_name, data.cohort.criterion, `Checkpoint ${data.probe.key}: ${memoryCheckpointLabel(data.probe)}`,
+        `Earlier context: ${memoryExposureLabels(data.probe)}`,
+        `${data.summary.assessed.toLocaleString()} of ${data.summary.observed_trials.toLocaleString()} observed drills assessed`,
+        `Not assessable: ${data.summary.not_assessable.toLocaleString()}`, `Not applicable: ${data.summary.not_applicable.toLocaleString()}`,
+        `Mean score: ${data.summary.mean === null ? 'Not assessed' : `${data.summary.mean.toLocaleString(undefined, { maximumFractionDigits: 2 })} / ${data.cohort.levels.length - 1}`}. ${data.cohort.direction === 'lower' ? 'Lower' : 'Higher'} is better.`,
+        ...data.results.map(row => `Drill ${row.trial_position + 1}: ${row.status.replaceAll('_', ' ')}${row.score === null ? '' : ` (${row.score.toLocaleString(undefined, { maximumFractionDigits: 2 })} / ${data.cohort.levels.length - 1})`}\n${workspaceLink(scope.workspace, `/campaigns/${campaign}/trials/${row.execution_id}?view=assessment&assessment=${row.assessment_id}`)}`),
+        `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+        ...(data.next ? [`Next page: firedrill report ${campaign} memory ${assessment} --checkpoint ${data.probe.key} --page ${data.page + 1}`] : [])].join('\n'));
+}
+async function comparisonCommand(args, prefix, scope, interactive, options, output) {
+    let baseline = args[2] ? identifier(args[2]) : undefined;
+    if (!baseline && !interactive)
+        throw new CliError('baseline_required', 'Pass a saved baseline simulation ID after compare. Interactive mode provides a selection.', 2);
+    if (!baseline)
+        baseline = identifier((await choosePage('Baseline simulation', `${prefix}/comparison-candidates`, scope, { ...options, search: undefined, page: undefined }, row => ({ label: row.name, detail: `${row.created_at} · Source ${row.source_revision.slice(0, 12)}` }))).id);
+    const supplied = args[3];
+    if (supplied && !['semantic', 'memory', 'style', 'checks', 'performance', 'usage', 'composite'].includes(supplied))
+        throw new CliError('arguments_invalid', 'Choose semantic, memory, style, checks, performance, usage or composite after the baseline ID.', 2);
+    const kind = (supplied ?? (interactive ? await selectOne('Compare', [{ value: 'semantic', label: 'Semantic scores' },
+        { value: 'memory', label: 'Memory checkpoints' }, { value: 'style', label: 'Style observations' }, { value: 'checks', label: 'Recorded checks' },
+        { value: 'performance', label: 'Conversation timing' }, { value: 'usage', label: 'Target model usage' }, { value: 'composite', label: 'Composite indices' }], options.signal) : 'semantic'));
+    if (options.side !== undefined && (!['semantic', 'memory', 'style', 'checks', 'composite', 'performance', 'usage'].includes(kind) || !args[4] && !interactive))
+        throw new CliError('arguments_invalid', 'Choose a comparison group before applying --side.', 2);
+    if (kind === 'composite') {
+        await compositeComparisonCommand(args, prefix, baseline, scope, interactive, options, output);
+        return;
+    }
+    if (kind === 'checks') {
+        await nativeCheckCommand(prefix, scope, interactive, options, output, args[4], baseline);
+        return;
+    }
+    if (kind === 'performance' || kind === 'usage') {
+        await performanceCommand(prefix, baseline, kind === 'usage' ? 'model' : 'conversation', scope, interactive, options, output, args[4]);
+        return;
+    }
+    let assessment = args[4] ? identifier(args[4]) : undefined;
+    if (options.checkpoint && (kind !== 'memory' || !assessment && !interactive))
+        throw new CliError('arguments_invalid', 'Choose a memory cohort assessment before selecting its checkpoint.', 2);
+    const base = new URLSearchParams({ baseline, kind });
+    const number = (value) => value === null ? 'Not assessed' : value.toLocaleString(undefined, { maximumFractionDigits: 2 });
+    const summary = (side, value, cohort) => {
+        const schedule = value.scenario;
+        const lines = [`${side}: ${number(value.mean)}${value.mean === null ? '' : kind === 'style' ? ' occurrences per observed drill' : ` / ${cohort.levels.length - 1}`}; ${value.assessed.toLocaleString()} assessed of ${value.observed.toLocaleString()} retained in this assessment group; ${value.not_assessable.toLocaleString()} not assessable; ${value.not_applicable.toLocaleString()} not applicable; ${value.missing.toLocaleString()} unavailable`,
+            `Scenario schedule: ${schedule.planned.toLocaleString()} planned; ${schedule.retained.toLocaleString()} retained; ${schedule.invoked.toLocaleString()} invocations observed; ${schedule.completed.toLocaleString()} completed; ${schedule.target_failed.toLocaleString()} agent failures; ${schedule.platform_failed.toLocaleString()} platform failures; ${schedule.timed_out.toLocaleString()} timed out; ${schedule.canceled.toLocaleString()} canceled; ${schedule.unfinished.toLocaleString()} unfinished.`,
+            `${value.without_assessment.toLocaleString()} retained drills outside this assessment group; ${schedule.changed_world.toLocaleString()} changed-world drills and ${schedule.unconfirmed_world.toLocaleString()} unconfirmed-world drills excluded from comparison scores.`];
+        if ('distribution' in value)
+            lines.push(`Score distribution, retained counts: ${value.distribution.map(bin => `${number(bin.minimum)} ${bin.upper_inclusive ? 'through' : 'to below'} ${number(bin.maximum)}: ${bin.count.toLocaleString()}`).join('; ')}.`);
+        return lines.join('\n');
+    };
+    if (!assessment && !interactive) {
+        const data = await api(`${prefix}/comparison?${base}&page=${options.page ?? '1'}&q=${encodeURIComponent(options.search ?? '')}`, { actor: scope.owner, signal: options.signal });
+        if (!comparisonPageMatches(data, { current: prefix.split('/').at(-1), baseline, kind }))
+            throw new CliError('assessment_comparison_changed', 'The selected simulation comparison could not be confirmed.');
+        output(data, [`Current: ${data.current.name} (${data.current.id})`, `Baseline: ${data.baseline.name} (${data.baseline.id})`,
+            ...Object.entries(data.context).map(([key, equal]) => `${key.replaceAll('_', ' ')}: ${equal === null ? 'Unknown' : equal ? 'Same recorded input' : 'Different'}`),
+            ...data.results.flatMap(row => [`${row.cohort.scenario_name}: ${row.cohort.criterion} (${row.cohort.assessment_id})`, summary('Current', row.current, row.cohort), summary('Baseline', row.baseline, row.cohort),
+                `Mean difference (current minus baseline): ${number(row.difference)}`]),
+            `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+            'Only compatible retained observations are grouped. This is not a causal winner or CI decision.'].join('\n'));
+        return;
+    }
+    const picked = !assessment;
+    if (!assessment)
+        assessment = identifier((await choosePage('Assessment group', `${prefix}/comparison?${base}`, scope, options, row => ({ label: `${row.cohort.scenario_name}: ${row.cohort.criterion}`, detail: `${row.cohort.model} · Current ${number(row.current.mean)} · Baseline ${number(row.baseline.mean)}` }))).cohort.assessment_id);
+    else if (options.search)
+        throw new CliError('arguments_invalid', 'Search applies to the group list, not one selected assessment.', 2);
+    const side = options.side ?? (interactive ? await selectOne('Show observations from', [
+        { value: 'both', label: 'Both simulations' }, { value: 'current', label: 'Current simulation' },
+        { value: 'baseline', label: 'Baseline simulation' }
+    ], options.signal) : 'both');
+    const params = new URLSearchParams({ ...Object.fromEntries(base), page: picked ? '1' : options.page ?? '1', ...(kind === 'memory' ? { probe: '0' } : {}) });
+    params.set('side', side);
+    const path = `${prefix}/comparison/${assessment}/observations`;
+    const readObservations = async () => {
+        const value = await api(`${path}?${params}`, { actor: scope.owner, signal: options.signal });
+        if (!comparisonObservationsMatch(value, { current: prefix.split('/').at(-1), baseline: baseline, kind,
+            assessment: assessment, side, ...(kind === 'memory' ? { probe: Number(params.get('probe') ?? '0') } : {}) }))
+            throw new CliError('assessment_comparison_changed', 'The selected comparison observations could not be confirmed.');
+        return value;
+    };
+    let data = await readObservations();
+    if (kind === 'memory' && data.kind === 'memory') {
+        const probes = data.cohort.memory.probes;
+        const index = options.checkpoint ? probes.findIndex(row => row.key === options.checkpoint) : interactive
+            ? await selectOne('Checkpoint', probes.map((row, value) => ({ value, label: `${memoryCheckpointLabel(row)}: ${row.key.replaceAll('_', ' ')}`, detail: row.expectation })), options.signal) : 0;
+        if (index < 0)
+            throw new CliError('checkpoint_unavailable', 'That checkpoint is not in this frozen criterion.', 2);
+        if (index !== 0) {
+            params.set('probe', String(index));
+            data = await readObservations();
+        }
+    }
+    output(data, [data.cohort.scenario_name, data.cohort.criterion, `Evaluator: ${data.cohort.model}`,
+        ...(kind === 'style' ? ['Selected prose occurrences, not a quality score.'] : [data.cohort.direction === 'lower' ? 'Lower scores are better.' : 'Higher scores are better.']),
+        ...(data.probe ? [`${memoryCheckpointLabel(data.probe)}: ${data.probe.expectation}`, `Earlier context: ${memoryExposureLabels(data.probe)}`] : []),
+        summary('Current', data.summary.current, data.cohort), summary('Baseline', data.summary.baseline, data.cohort),
+        `Mean difference (current minus baseline): ${number(data.summary.difference)}`,
+        ...data.results.map(row => `${row.side === 'current' ? 'Current' : 'Baseline'} drill ${row.trial_position + 1}: ${row.status.replaceAll('_', ' ')} (${number(row.score)})\n${workspaceLink(scope.workspace, `/campaigns/${row.campaign_id}/trials/${row.execution_id}?view=assessment&assessment=${row.assessment_id}`)}`),
+        `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+        ...(data.next ? [`Continue: firedrill report ${prefix.split('/').at(-1)} compare ${baseline} ${kind} ${assessment} --workspace ${identifier(prefix.split('/')[3])} --page ${data.page + 1} --side ${side}${data.probe ? ' --checkpoint ' + data.probe.key : ''}${options.json ? ' --json' : ''}`] : []),
+        'Missing observations are not zero. Independent drills are not one memory session.'].join('\n'));
+}
+const nativeCheckMethods = { exact: 'Objective', semantic: 'Judged', both: 'Objective and judged', unknown: 'Definition unavailable' };
+const checkCounts = (label, value) => `${label}: ${value.met.toLocaleString()} met; ${value.unmet.toLocaleString()} unmet; ${value.unconfirmed.toLocaleString()} unconfirmed; ${value.reported.toLocaleString()} reported of ${value.records.toLocaleString()} retained drill results`;
+async function nativeCheckCommand(prefix, scope, interactive, options, output, supplied, baseline) {
+    if (options.checkpoint)
+        throw new CliError('arguments_invalid', 'Checkpoint selection applies only to memory reports.', 2);
+    let check = supplied ? identifier(supplied) : undefined;
+    if (check && options.search)
+        throw new CliError('arguments_invalid', 'Search applies to check groups, not an already selected check.', 2);
+    if (check && options.checkMethod !== undefined)
+        throw new CliError('arguments_invalid', 'Check type filters apply to group lists, not a selected original check.', 2);
+    if (!check && !interactive && (options.status !== undefined || options.side !== undefined))
+        throw new CliError('check_required', 'Choose a check ID before filtering its observations by status or side.', 2);
+    if (!baseline && options.side === 'baseline')
+        throw new CliError('baseline_required', 'Choose a saved baseline before requesting its check observations.', 2);
+    const method = options.checkMethod ?? '';
+    const groups = new URLSearchParams({ method, ...(baseline ? { baseline } : {}) });
+    const path = `${prefix}/check-groups`;
+    if (!check && !interactive) {
+        groups.set('page', options.page ?? '1');
+        groups.set('q', options.search ?? '');
+        const data = await api(`${path}?${groups}`, { actor: scope.owner, signal: options.signal });
+        if (!checkGroupsMatch(data, prefix.split('/').at(-1), baseline, method))
+            throw new CliError('native_check_report_changed', 'The selected check groups could not be confirmed.');
+        output(data, [...(data.baseline ? [`Current: ${data.current.name} (${data.current.id})`, `Baseline: ${data.baseline.name} (${data.baseline.id})`,
+                ...Object.entries(data.context ?? {}).map(([key, equal]) => `${key.replaceAll('_', ' ')}: ${equal === null ? 'Unknown' : equal ? 'Same recorded input' : 'Different'}`)] : []),
+            ...data.results.flatMap(row => [`${row.check.scenario_name}: ${row.check.name} (${row.check.id})`, nativeCheckMethods[row.check.method] ?? nativeCheckMethods.unknown,
+                checkCounts('Current', row.current), ...(row.baseline ? [checkCounts('Baseline', row.baseline)] : []),
+                ...(!row.check.definition_known ? ['Original definition unavailable; not matched across simulations.'] : [])]),
+            ...(!data.count ? ['No matching retained check results.'] : []),
+            `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+            ...(data.next ? [`Continue: firedrill report ${prefix.split('/').at(-1)} ${baseline ? 'compare ' + baseline + ' checks' : 'checks'} --workspace ${identifier(prefix.split('/')[3])} --page ${data.page + 1}${method ? ' --method ' + method : ''}${options.search ? " --search '" + options.search.replaceAll("'", "'\\''") + "'" : ''}${options.json ? ' --json' : ''}`] : []),
+            'Counts cover retained drill results. An unconfirmed or missing check is not a failure or a semantic score.'].join('\n'));
+        return;
+    }
+    const picked = !check;
+    if (!check)
+        check = identifier((await choosePage('Recorded check', `${path}?${groups}`, scope, options, row => ({ label: `${row.check.scenario_name}: ${row.check.name}`, detail: `${nativeCheckMethods[row.check.method] ?? nativeCheckMethods.unknown} · ${row.current.unmet} current unmet${row.baseline ? ` · ${row.baseline.unmet} baseline unmet` : ''}` }))).check.id);
+    const side = options.side ?? (baseline && interactive ? await selectOne('Simulation', [{ value: 'both', label: 'Both simulations' }, { value: 'current', label: 'Current' }, { value: 'baseline', label: 'Baseline' }], options.signal) : 'both');
+    const status = options.status ?? (interactive ? await selectOne('Check results', [{ value: '', label: 'All results' }, { value: 'unmet', label: 'Unmet' }, { value: 'met', label: 'Met' }, { value: 'unconfirmed', label: 'Unconfirmed' }], options.signal) : '');
+    const query = new URLSearchParams({ page: picked ? '1' : options.page ?? '1', side, status, ...(baseline ? { baseline } : {}) });
+    const data = await api(`${path}/${check}/observations?${query}`, { actor: scope.owner, signal: options.signal });
+    if (!checkObservationsMatch(data, { current: prefix.split('/').at(-1), baseline, check, side, status }))
+        throw new CliError('native_check_report_changed', 'The selected check observations could not be confirmed.');
+    output(data, [`${data.check.scenario_name}: ${data.check.name}`, nativeCheckMethods[data.check.method] ?? nativeCheckMethods.unknown,
+        checkCounts('Current', data.summary.current), ...(data.summary.baseline ? [checkCounts('Baseline', data.summary.baseline)] : []),
+        ...(!data.check.definition_known ? ['Original definition unavailable; not matched across simulations.'] : []),
+        ...data.results.map(row => `${baseline ? row.side === 'baseline' ? 'Baseline ' : 'Current ' : ''}drill ${row.trial_position + 1}: ${row.reported ? row.status : 'Not reported'}${row.reason_excerpt ? `\n${row.reason_excerpt}${row.reason_truncated ? '\nOpen the original check for the full explanation.' : ''}` : ''}\nInspect: firedrill report ${row.campaign_id} drill ${row.execution_id} check-observation ${row.id} --workspace ${scope.workspace}\n${workspaceLink(scope.workspace, `/campaigns/${row.campaign_id}/trials/${row.execution_id}?view=assessment&check_observation=${row.id}`)}`),
+        ...(!data.count ? ['No retained check results match these filters.'] : []), `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+        ...(data.next ? [`Continue: firedrill report ${prefix.split('/').at(-1)} ${baseline ? 'compare ' + baseline + ' checks' : 'checks'} ${check} --workspace ${identifier(prefix.split('/')[3])} --page ${data.page + 1} --side ${side}${status ? ' --status ' + status : ''}${options.json ? ' --json' : ''}`] : [])].join('\n'));
+}
+async function performanceCommand(prefix, baseline, kind, scope, interactive, options, output, supplied) {
+    if (options.checkpoint)
+        throw new CliError('arguments_invalid', 'Checkpoints apply only to memory reports.', 2);
+    let group = supplied ? identifier(supplied) : undefined;
+    if (group && options.search)
+        throw new CliError('arguments_invalid', 'Search applies to measurement groups, not an already selected group.', 2);
+    const current = identifier(prefix.split('/').at(-1));
+    const auth = { actor: scope.owner, workspace: scope.workspace, signal: options.signal };
+    const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+    const command = `firedrill report ${current} compare ${baseline} ${kind === 'model' ? 'usage' : 'performance'}`;
+    const continuation = (data, suffix, filters = '') => data.next
+        ? [`Continue: ${command}${suffix} --workspace ${scope.workspace} --page ${data.page + 1}${filters}${options.json ? ' --json' : ''}`] : [];
+    const values = new URLSearchParams({ baseline, kind });
+    const path = `${prefix}/performance-groups`;
+    const measured = (value) => value === null ? 'Not measured' : value;
+    const timing = (value) => value === null ? 'Not measured' : `${value}ms`;
+    const describe = (label, value) => [`${label}: ${value.records.toLocaleString()} ${kind === 'model' ? 'request records' : 'retained drill results'}`,
+        `${kind === 'model' ? 'Mean request elapsed' : 'Mean conversation duration'}: ${timing(value.elapsed_ms.mean)}; ${value.timed_records.toLocaleString()} timed records; range ${timing(value.elapsed_ms.minimum)} to ${timing(value.elapsed_ms.maximum)}`,
+        ...(value.turns ? [`Mean turns: ${measured(value.turns.mean)}; ${value.turns.coverage.toLocaleString()} measured results`] : []),
+        ...Object.entries(value.tokens ?? {}).map(([name, entry]) => `${name.replaceAll('_', ' ')}: ${measured(entry.total)} total; ${measured(entry.mean)} mean per measured request; ${entry.coverage.toLocaleString()} measured of ${value.records.toLocaleString()}`),
+        ...(value.requests ? [`Completed ${value.requests.completed}; failed ${value.requests.failed}; interrupted ${value.requests.interrupted}; unfinished ${value.requests.pending}`] : [])];
+    const identity = (value) => `${value.scenario_name}${kind === 'model' ? ` · ${value.requested_model} · ${value.provider ?? 'Provider unrecorded'}${value.operation ? ' · ' + value.operation : ''}` : ''}`;
+    const limitation = kind === 'model' ? 'Target-model request usage only, including available partial fields. Elapsed includes relay/network handling. Requested models are not resolved model versions; no dollar costs or platform evaluator spend are estimated.'
+        : 'Conversation measurements from original drill results, not startup/cleanup, model inference latency or total drill work.';
+    if (!group && !interactive) {
+        const data = await api(`${path}?${values}&page=${options.page ?? '1'}&q=${encodeURIComponent(options.search ?? '')}`, auth);
+        if (!performanceGroupsMatch(data, current, baseline, kind))
+            throw new CliError('report_unavailable', 'This measurement comparison could not be confirmed. Reopen the report.');
+        output(data, [`Current: ${data.current.name} (${data.current.id})`, `Baseline: ${data.baseline.name} (${data.baseline.id})`,
+            ...Object.entries(data.context).map(([key, equal]) => `${key.replaceAll('_', ' ')}: ${equal === null ? 'Unknown' : equal ? 'Same recorded input' : 'Different'}`),
+            ...data.results.flatMap(row => [`${identity(row.cohort)} (${row.cohort.id})`, ...describe('Current', row.current), ...describe('Baseline', row.baseline)]),
+            ...(!data.count ? ['No matching retained measurements.'] : []), `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+            ...continuation(data, '', options.search ? ' --search ' + quote(options.search) : ''), limitation,
+            'Missing measurements are not zero. Exact scenario/provider/model groups and setup differences do not establish a causal winner.'].join('\n'));
+        return;
+    }
+    const picked = !group;
+    if (!group)
+        group = identifier((await choosePage('Measurement group', `${path}?${values}`, scope, options, row => ({ label: identity(row.cohort), detail: `Current ${row.current.records} retained · Baseline ${row.baseline.records} retained` }), value => performanceGroupsMatch(value, current, baseline, kind))).cohort.id);
+    const side = options.side ?? (interactive ? await selectOne('Simulation', [{ value: 'both', label: 'Both simulations' }, { value: 'current', label: 'Current' }, { value: 'baseline', label: 'Baseline' }], options.signal) : 'both');
+    values.set('side', side);
+    values.set('page', picked ? '1' : options.page ?? '1');
+    const data = await api(`${path}/${group}/observations?${values}`, auth);
+    if (!performanceObservationsMatch(data, { current, baseline, kind, cohort: group, side }))
+        throw new CliError('report_unavailable', 'These retained measurements could not be confirmed. Reopen the comparison.');
+    output(data, [identity(data.cohort), ...describe('Current', data.summary.current), ...describe('Baseline', data.summary.baseline),
+        ...data.results.flatMap(row => [`${row.side === 'baseline' ? 'Baseline' : 'Current'} drill ${row.trial_position + 1}: ${timing(row.elapsed_ms)}${kind === 'model' ? `; ${row.state?.replaceAll('_', ' ') ?? 'Unconfirmed'}` : `; ${measured(row.turns)} turns`}`,
+            ...Object.entries(row.tokens ?? {}).map(([name, value]) => `${name.replaceAll('_', ' ')}: ${measured(value)}`),
+            workspaceLink(scope.workspace, `/campaigns/${row.campaign_id}/trials/${row.execution_id}`)]),
+        ...(!data.count ? ['No retained measurements on this side.'] : []), `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+        ...continuation(data, ` ${group}`, ` --side ${side}`), limitation].join('\n'));
+}
+async function compositeComparisonCommand(args, prefix, baseline, scope, interactive, options, output) {
+    if (options.checkpoint)
+        throw new CliError('arguments_invalid', 'Checkpoints apply only to memory reports.', 2);
+    let group = args[4];
+    if (group && !/^[a-f0-9]{64}$/.test(group))
+        throw new CliError('comparison_group_required', 'Choose a composite cohort ID from this comparison.', 2);
+    if (group && options.search)
+        throw new CliError('arguments_invalid', 'Search applies to composite groups, not an already selected group.', 2);
+    if (args[5] && !['models', 'trials'].includes(args[5]))
+        throw new CliError('arguments_invalid', 'Choose models or drills after the composite cohort ID.', 2);
+    const filtered = options.side !== undefined || options.status !== undefined || options.evaluator !== undefined;
+    if (filtered && (args[5] === 'models' || !interactive && (!group || args[5] !== 'trials')))
+        throw new CliError('arguments_invalid', 'Choose a composite cohort and drills before applying --side, --status or --evaluator.', 2);
+    const current = identifier(prefix.split('/').at(-1));
+    const auth = { actor: scope.owner, workspace: scope.workspace, signal: options.signal };
+    const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+    const command = `firedrill report ${current} compare ${baseline} composite`;
+    const continuation = (data, suffix, filters = '') => data.next
+        ? [`Continue: ${command}${suffix} --workspace ${scope.workspace} --page ${data.page + 1}${filters}${options.json ? ' --json' : ''}`] : [];
+    const base = new URLSearchParams({ baseline });
+    const path = `${prefix}/composite-comparison`;
+    const number = (value) => value === null ? 'Unavailable' : value.toLocaleString(undefined, { maximumFractionDigits: 2 });
+    const summary = (label, value) => `${label}: ${number(value.mean)}${value.mean === null ? '' : ' / 100'}; ${value.assessed.toLocaleString()} indexed of ${value.records.toLocaleString()} retained drills; ${value.unavailable.toLocaleString()} unavailable; range ${number(value.minimum)} to ${number(value.maximum)}; ${value.checks_unmet.toLocaleString()} with unmet checks, ${value.checks_unconfirmed.toLocaleString()} with unconfirmed checks, ${value.execution_incomplete.toLocaleString()} incomplete`;
+    const schedule = (cohort) => `Current scenario schedule: ${cohort.current.retained.toLocaleString()} retained of ${cohort.current.planned.toLocaleString()} planned; ${cohort.current.changed_world.toLocaleString()} changed-world and ${cohort.current.unconfirmed_world.toLocaleString()} unconfirmed-world drills excluded. Baseline: ${cohort.baseline.retained.toLocaleString()} retained of ${cohort.baseline.planned.toLocaleString()} planned; ${cohort.baseline.changed_world.toLocaleString()} changed-world and ${cohort.baseline.unconfirmed_world.toLocaleString()} unconfirmed-world drills excluded.`;
+    const limitation = 'Only exact frozen scenario/world/criteria/weights/mappings/check/calculation cohorts are grouped, with evaluator versions separate. Missing inputs are not zero or redistributed weight. This is not a probability, CI result or causal winner.';
+    if (!group && !interactive) {
+        const data = await api(`${path}?${base}&page=${options.page ?? '1'}&q=${encodeURIComponent(options.search ?? '')}`, auth);
+        if (!compositeGroupsMatch(data, current, baseline))
+            throw new CliError('report_unavailable', 'This composite comparison could not be confirmed. Reopen the report.');
+        output(data, [`Current: ${data.current.name} (${data.current.id})`, `Baseline: ${data.baseline.name} (${data.baseline.id})`,
+            ...Object.entries(data.context).map(([key, equal]) => `${key.replaceAll('_', ' ')}: ${equal === null ? 'Unknown' : equal ? 'Same recorded input' : 'Different'}`),
+            ...data.results.flatMap(row => [`${row.scenario_name} (${row.id})`, `${row.dimensions.length} weighted criteria.`, schedule(row),
+                ...(!row.check_definitions_known ? ['Original check definitions unconfirmed; this group is not matched across simulations.'] : []),
+                ...(!row.calculation_supported ? ['This retained calculation version is not summarized; open original drills.'] : [])]),
+            ...(!data.count ? ['No matching frozen composite definitions.'] : []), `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+            ...continuation(data, '', options.search ? ' --search ' + quote(options.search) : ''), limitation].join('\n'));
+        return;
+    }
+    const picked = !group;
+    if (!group)
+        group = (await choosePage('Composite definition', `${path}?${base}`, scope, options, row => ({ label: row.scenario_name, detail: `${row.dimensions.length} weighted criteria · Current ${row.current.retained} retained · Baseline ${row.baseline.retained} retained` }), value => compositeGroupsMatch(value, current, baseline))).id;
+    if (!/^[a-f0-9]{64}$/.test(group))
+        throw new CliError('report_unavailable', 'The saved composite comparison could not be read.');
+    const action = args[5] ?? (filtered ? 'trials' : interactive ? await selectOne('Inspect', [{ value: 'models', label: 'Evaluator summaries' }, { value: 'trials', label: 'Drill indices' }], options.signal) : 'models');
+    const params = new URLSearchParams({ baseline, page: picked ? '1' : options.page ?? '1' });
+    if (action === 'models') {
+        const data = await api(`${path}/${group}/models?${params}`, auth);
+        if (!compositeModelsMatch(data, current, baseline, group))
+            throw new CliError('report_unavailable', 'This evaluator summary could not be confirmed. Reopen the comparison.');
+        output(data, [data.cohort.scenario_name, schedule(data.cohort), ...data.cohort.dimensions.map(row => `${row.name}: relative weight ${row.weight}; numeric mapping ${row.values.join(', ')}`),
+            ...data.results.flatMap(row => [row.model ?? 'Evaluator unavailable', summary('Current', row.current), summary('Baseline', row.baseline),
+                `Mean difference (current minus baseline): ${row.difference === null ? 'Not comparable' : `${row.difference > 0 ? '+' : ''}${number(row.difference)}`}`]),
+            ...(!data.count ? ['No retained drill slots for this definition yet.'] : []), `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+            ...continuation(data, ` ${group} models`), limitation].join('\n'));
+        return;
+    }
+    const side = options.side ?? (interactive ? await selectOne('Simulation', [{ value: 'both', label: 'Both simulations' }, { value: 'current', label: 'Current' }, { value: 'baseline', label: 'Baseline' }], options.signal) : 'both');
+    const status = options.status ?? (interactive ? await selectOne('Index', [{ value: 'all', label: 'All drills' }, { value: 'available', label: 'Available' }, { value: 'unavailable', label: 'Unavailable' }], options.signal) : 'all');
+    params.set('side', side);
+    params.set('status', status);
+    const model = options.evaluator === undefined ? undefined : options.evaluator === 'unavailable' ? null : options.evaluator;
+    params.set('model_scope', model === undefined ? 'all' : model === null ? 'unavailable' : 'known');
+    if (model !== undefined && model !== null)
+        params.set('model', model);
+    const data = await api(`${path}/${group}/observations?${params}`, auth);
+    if (!compositeObservationsMatch(data, { current, baseline, cohort: group, side, status, model }))
+        throw new CliError('report_unavailable', 'These drill indices could not be confirmed. Reopen the comparison.');
+    output(data, [data.cohort.scenario_name, schedule(data.cohort), ...data.results.map(row => `${row.side === 'current' ? 'Current' : 'Baseline'} drill ${row.trial_position + 1}: ${row.value === null ? 'Unavailable' : `${number(row.value)} / 100`}; ${row.state.replaceAll('_', ' ')}; ${row.model ?? 'Evaluator unavailable'}\n${workspaceLink(scope.workspace, `/campaigns/${row.campaign_id}/trials/${row.execution_id}?view=assessment`)}`),
+        ...(!data.count ? ['No retained drills match these filters.'] : []), `Page ${data.page} of ${Math.max(1, Math.ceil(data.count / data.page_size))}`,
+        ...continuation(data, ` ${group} drills`, ` --side ${side} --status ${status}${options.evaluator === undefined ? '' : ' --evaluator ' + quote(options.evaluator)}`), limitation].join('\n'));
+}