@petepetrash/circuit 0.1.0

package/dist/runtime/projections/progress.js

@@ -0,0 +1,679 @@
+import { join } from 'node:path';
+import { progressDisplay, progressPresentation, reportProgress, } from '../../shared/progress-output.js';
+import { runResultPath } from '../../shared/result-path.js';
+import { WRITE_CAPABLE_WORKER_DISCLOSURE, flowMayInvokeWriteCapableWorker, } from '../../shared/write-capable-worker-disclosure.js';
+import { connectorFilesystemCapability, connectorFromTrace, fanoutBranchKind, fanoutPolicy, optionalRunClosedOutcome, relayRoleFromTrace, runOutcome, runReason, stringArrayValue, } from '../trace/trace-fields.js';
+import { tournamentCheckpointPresentation } from './tournament-checkpoint-context.js';
+function stepTitle(input) {
+    if (input.stepId === undefined)
+        return '<unknown step>';
+    return input.flow.steps.find((step) => step.id === input.stepId)?.title ?? input.stepId;
+}
+function flowLabel(flowId) {
+    return flowId
+        .split('-')
+        .filter((part) => part.length > 0)
+        .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join(' ');
+}
+function fallbackRelayStartedStatusText(role) {
+    if (role === 'researcher') {
+        return 'Asking the researcher to clarify the task...';
+    }
+    if (role === 'reviewer') {
+        return 'Asking the reviewer to check the result...';
+    }
+    return 'Asking the specialist to make the change...';
+}
+function fallbackRelayCompletedStatusText(role) {
+    if (role === 'researcher') {
+        return 'Finished clarifying the task.';
+    }
+    if (role === 'reviewer') {
+        return 'Finished checking the result.';
+    }
+    return 'Finished the specialist pass.';
+}
+function relayStartedTextFor(input) {
+    return input.display.relayStartedText ?? fallbackRelayStartedStatusText(input.role);
+}
+function relayCompletedTextFor(input) {
+    return input.display.relayCompletedText ?? fallbackRelayCompletedStatusText(input.role);
+}
+function circuitDisplayText(statusText) {
+    return `Circuit: ${statusText}`;
+}
+function appendStatus(blockId, statusText) {
+    return progressPresentation({ blockId, lineMode: 'append', statusText });
+}
+function replaceStatus(blockId, slotId, statusText) {
+    return progressPresentation({
+        blockId,
+        lineMode: 'replace_slot',
+        slotId,
+        statusText,
+    });
+}
+function suppressStatus(blockId) {
+    return progressPresentation({ blockId, lineMode: 'suppress' });
+}
+function progressTasks(flow, stepDisplayById, statuses) {
+    return flow.steps.map((step) => ({
+        id: step.id,
+        title: stepDisplayById.get(step.id)?.taskTitle ?? step.title ?? step.id,
+        status: statuses.get(step.id) ?? 'pending',
+    }));
+}
+function reportTaskListProgress(input) {
+    reportProgress(input.progress, {
+        schema_version: 1,
+        type: 'task_list.updated',
+        run_id: input.runId,
+        flow_id: input.flowId,
+        recorded_at: input.recordedAt,
+        label: input.label,
+        display: progressDisplay(input.displayText, 'detail', input.tone ?? 'info'),
+        presentation: suppressStatus(input.runId),
+        tasks: progressTasks(input.flow, input.stepDisplayById, input.statuses),
+    });
+}
+function readJsonReport(files, runDir, reportPath) {
+    const text = files.readText(join(runDir, reportPath));
+    if (text === undefined)
+        throw new Error(`progress projection could not read ${reportPath}`);
+    return JSON.parse(text);
+}
+function warningRecordsFromReport(body) {
+    if (body === null || typeof body !== 'object' || Array.isArray(body))
+        return [];
+    const raw = body.evidence_warnings;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((item) => {
+        if (item === null || typeof item !== 'object' || Array.isArray(item))
+            return [];
+        const record = item;
+        if (typeof record.kind !== 'string' || typeof record.message !== 'string')
+            return [];
+        return [
+            {
+                kind: record.kind,
+                message: record.message,
+                ...(typeof record.path === 'string' ? { path: record.path } : {}),
+            },
+        ];
+    });
+}
+function reportEvidenceProgress(input) {
+    let body;
+    try {
+        body = readJsonReport(input.files, input.runDir, input.traceEntry.report_path);
+    }
+    catch {
+        return;
+    }
+    if (body === null || typeof body !== 'object' || Array.isArray(body))
+        return;
+    const record = body;
+    const hasEvidence = Object.hasOwn(record, 'evidence');
+    const warnings = warningRecordsFromReport(record);
+    if (!hasEvidence && warnings.length === 0)
+        return;
+    reportProgress(input.progress, {
+        schema_version: 1,
+        type: 'evidence.collected',
+        run_id: input.runId,
+        flow_id: input.flowId,
+        recorded_at: input.recordedAt,
+        label: warnings.length > 0 ? 'Collected evidence with warnings' : 'Collected evidence',
+        display: progressDisplay(warnings.length > 0
+            ? `Circuit: Collected evidence with ${warnings.length} warning${warnings.length === 1 ? '' : 's'}.`
+            : 'Circuit: Collected evidence.', 'major', warnings.length > 0 ? 'warning' : 'info'),
+        presentation: warnings.length > 0
+            ? appendStatus(input.runId, `Collected evidence with ${warnings.length} warning${warnings.length === 1 ? '' : 's'}.`)
+            : suppressStatus(input.runId),
+        step_id: input.traceEntry.step_id,
+        report_path: input.traceEntry.report_path,
+        report_schema: input.traceEntry.report_schema,
+        warning_count: warnings.length,
+    });
+    for (const warning of warnings) {
+        reportProgress(input.progress, {
+            schema_version: 1,
+            type: 'evidence.warning',
+            run_id: input.runId,
+            flow_id: input.flowId,
+            recorded_at: input.recordedAt,
+            label: 'Evidence warning',
+            display: progressDisplay(`Circuit: Evidence warning: ${warning.message}`, 'major', 'warning'),
+            presentation: appendStatus(input.runId, `Evidence warning: ${warning.message}`),
+            step_id: input.traceEntry.step_id,
+            report_path: input.traceEntry.report_path,
+            warning_kind: warning.kind,
+            message: warning.message,
+            ...(warning.path === undefined ? {} : { path: warning.path }),
+        });
+    }
+}
+function checkpointPrompt(files, requestPath) {
+    try {
+        const text = files.readText(requestPath);
+        if (text === undefined)
+            throw new Error(`progress projection could not read ${requestPath}`);
+        const raw = JSON.parse(text);
+        if (raw !== null && typeof raw === 'object' && !Array.isArray(raw)) {
+            const prompt = raw.prompt;
+            if (typeof prompt === 'string' && prompt.length > 0)
+                return prompt;
+        }
+    }
+    catch {
+        // A damaged request file should not block progress projection.
+    }
+    return 'Choose how to continue this checkpoint.';
+}
+function checkpointChoiceLabel(choice) {
+    return choice
+        .split(/[-_]/)
+        .filter((part) => part.length > 0)
+        .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join(' ');
+}
+function checkpointRequestPath(runDir, requestPath) {
+    return requestPath.startsWith('/') ? requestPath : join(runDir, requestPath);
+}
+function shouldWarnAboutWriteCapableWorker(flow) {
+    return (flowMayInvokeWriteCapableWorker(flow.id) ||
+        flow.steps.some((step) => step.kind === 'relay' && step.role === 'implementer'));
+}
+function stepDisplay(input) {
+    const title = stepTitle({ flow: input.flow, stepId: input.stepId });
+    const metadata = input.stepDisplayById.get(input.stepId);
+    if (metadata !== undefined) {
+        return {
+            title,
+            taskTitle: metadata.taskTitle,
+            activeText: metadata.activeText,
+            ...(metadata.relayRole === undefined ? {} : { relayRole: metadata.relayRole }),
+            ...(metadata.relayStartedText === undefined
+                ? {}
+                : { relayStartedText: metadata.relayStartedText }),
+            ...(metadata.relayCompletedText === undefined
+                ? {}
+                : { relayCompletedText: metadata.relayCompletedText }),
+        };
+    }
+    return {
+        title,
+        taskTitle: title,
+        activeText: `Working on ${title.toLowerCase()}`,
+    };
+}
+export function createProgressProjector(input) {
+    const projectionFiles = input.files ?? { readText: () => undefined };
+    const taskStatuses = new Map(input.flow.steps.map((step) => [step.id, 'pending']));
+    const stepDisplayById = new Map(input.progressSurface?.steps.map((step) => [step.stepId, step]) ?? []);
+    const activeAttempts = new Map();
+    const flowId = input.flow.id;
+    const runId = input.runId;
+    return (entry) => {
+        const recordedAt = entry.recorded_at ?? new Date(0).toISOString();
+        switch (entry.kind) {
+            case 'run.bootstrapped': {
+                const shouldWarn = shouldWarnAboutWriteCapableWorker(input.flow);
+                const startedText = `Circuit: Started ${flowLabel(input.flow.id)}.`;
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'run.started',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: 'Started Circuit run',
+                    display: progressDisplay(shouldWarn ? `${startedText} ${WRITE_CAPABLE_WORKER_DISCLOSURE}` : startedText, 'major', shouldWarn ? 'warning' : 'info'),
+                    presentation: shouldWarn
+                        ? appendStatus(runId, WRITE_CAPABLE_WORKER_DISCLOSURE)
+                        : suppressStatus(runId),
+                    run_folder: input.runDir,
+                });
+                reportTaskListProgress({
+                    progress: input.progress,
+                    runId,
+                    flowId,
+                    flow: input.flow,
+                    stepDisplayById,
+                    recordedAt,
+                    statuses: taskStatuses,
+                    label: 'Flow checklist initialized',
+                    displayText: 'Circuit: Prepared the flow checklist.',
+                });
+                break;
+            }
+            case 'step.entered': {
+                const stepId = entry.step_id;
+                if (stepId === undefined || entry.attempt === undefined)
+                    break;
+                activeAttempts.set(stepId, entry.attempt);
+                taskStatuses.set(stepId, 'in_progress');
+                const display = stepDisplay({ flow: input.flow, stepDisplayById, stepId });
+                // Slice loop (deep-depth Build): when this step runs one slice of a
+                // slice loop, surface which slice so the operator can follow the
+                // per-slice implement+verify gating rather than seeing the same line
+                // repeat. slice_index is 0-based; show it 1-based.
+                const activeText = typeof entry.slice_index === 'number'
+                    ? `${display.activeText} (slice ${entry.slice_index + 1})`
+                    : display.activeText;
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'step.started',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: display.title,
+                    display: progressDisplay(`Circuit: ${activeText}...`, 'major', 'info'),
+                    presentation: appendStatus(runId, `${activeText}...`),
+                    step_id: stepId,
+                    step_title: display.title,
+                    attempt: entry.attempt,
+                });
+                reportTaskListProgress({
+                    progress: input.progress,
+                    runId,
+                    flowId,
+                    flow: input.flow,
+                    stepDisplayById,
+                    recordedAt,
+                    statuses: taskStatuses,
+                    label: `${display.title} in progress`,
+                    displayText: `Circuit: ${display.activeText}...`,
+                });
+                break;
+            }
+            case 'relay.started': {
+                const stepId = entry.step_id;
+                if (stepId === undefined)
+                    break;
+                const connector = connectorFromTrace(entry);
+                const role = relayRoleFromTrace(entry);
+                if (connector === undefined || role === undefined)
+                    break;
+                const display = stepDisplay({ flow: input.flow, stepDisplayById, stepId });
+                const capability = connectorFilesystemCapability(connector);
+                const statusText = relayStartedTextFor({ role, display });
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'relay.started',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: `Running ${role} relay with ${connector.name}`,
+                    display: progressDisplay(circuitDisplayText(statusText), 'major', 'info'),
+                    presentation: replaceStatus(runId, `${stepId}:relay`, statusText),
+                    step_id: stepId,
+                    step_title: display.title,
+                    attempt: activeAttempts.get(stepId) ?? entry.attempt ?? 1,
+                    role,
+                    connector_name: connector.name,
+                    connector_kind: connector.kind,
+                    filesystem_capability: capability,
+                });
+                break;
+            }
+            case 'relay.completed': {
+                const stepId = entry.step_id;
+                if (stepId === undefined ||
+                    entry.verdict === undefined ||
+                    entry.duration_ms === undefined) {
+                    break;
+                }
+                const display = stepDisplay({ flow: input.flow, stepDisplayById, stepId });
+                const role = relayRoleFromTrace(entry) ?? display.relayRole ?? 'implementer';
+                const statusText = relayCompletedTextFor({ role, display });
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'relay.completed',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: `Relay completed with ${entry.verdict}`,
+                    display: progressDisplay(circuitDisplayText(statusText), 'major', 'success'),
+                    presentation: replaceStatus(runId, `${stepId}:relay`, statusText),
+                    step_id: stepId,
+                    step_title: display.title,
+                    attempt: activeAttempts.get(stepId) ?? entry.attempt ?? 1,
+                    verdict: entry.verdict,
+                    duration_ms: entry.duration_ms,
+                });
+                break;
+            }
+            case 'step.report_written': {
+                reportEvidenceProgress({
+                    progress: input.progress,
+                    runDir: input.runDir,
+                    flowId,
+                    runId,
+                    recordedAt,
+                    traceEntry: entry,
+                    files: projectionFiles,
+                });
+                break;
+            }
+            case 'fanout.started': {
+                const stepId = entry.step_id;
+                const branchIds = stringArrayValue(entry.branch_ids);
+                if (stepId === undefined || branchIds === undefined)
+                    break;
+                const title = stepTitle({ flow: input.flow, stepId });
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'fanout.started',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: `Started ${title} fanout`,
+                    display: progressDisplay(`Circuit: Comparing ${branchIds.length} option${branchIds.length === 1 ? '' : 's'}...`, 'major', 'info'),
+                    presentation: replaceStatus(runId, `${stepId}:fanout`, `Comparing ${branchIds.length} option${branchIds.length === 1 ? '' : 's'}...`),
+                    step_id: stepId,
+                    step_title: title,
+                    branch_count: branchIds.length,
+                    branch_ids: branchIds,
+                });
+                break;
+            }
+            case 'fanout.branch_started': {
+                const stepId = entry.step_id;
+                const branchKind = fanoutBranchKind(entry.branch_kind);
+                if (stepId === undefined || entry.branch_id === undefined || branchKind === undefined) {
+                    break;
+                }
+                const title = stepTitle({ flow: input.flow, stepId });
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'fanout.branch_started',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: `Started branch ${entry.branch_id}`,
+                    display: progressDisplay(`Circuit: Started branch ${entry.branch_id}.`, 'detail', 'info'),
+                    presentation: suppressStatus(runId),
+                    step_id: stepId,
+                    step_title: title,
+                    branch_id: entry.branch_id,
+                    branch_kind: branchKind,
+                    ...(entry.child_run_id === undefined
+                        ? {}
+                        : { child_run_id: entry.child_run_id }),
+                    ...(entry.worktree_path === undefined ? {} : { worktree_path: entry.worktree_path }),
+                });
+                break;
+            }
+            case 'fanout.branch_completed': {
+                const stepId = entry.step_id;
+                const childOutcome = optionalRunClosedOutcome(entry.child_outcome);
+                const branchKind = fanoutBranchKind(entry.branch_kind);
+                if (stepId === undefined ||
+                    entry.branch_id === undefined ||
+                    branchKind === undefined ||
+                    childOutcome === undefined ||
+                    entry.verdict === undefined ||
+                    entry.duration_ms === undefined) {
+                    break;
+                }
+                const title = stepTitle({ flow: input.flow, stepId });
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'fanout.branch_completed',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: `Branch ${entry.branch_id} ${childOutcome}`,
+                    display: progressDisplay(`Circuit: Branch ${entry.branch_id} ${childOutcome}.`, 'detail', childOutcome === 'complete' ? 'success' : 'error'),
+                    presentation: suppressStatus(runId),
+                    step_id: stepId,
+                    step_title: title,
+                    branch_id: entry.branch_id,
+                    branch_kind: branchKind,
+                    ...(entry.child_run_id === undefined
+                        ? {}
+                        : { child_run_id: entry.child_run_id }),
+                    child_outcome: childOutcome,
+                    verdict: entry.verdict,
+                    duration_ms: entry.duration_ms,
+                });
+                break;
+            }
+            case 'fanout.joined': {
+                const stepId = entry.step_id;
+                const policy = fanoutPolicy(entry.policy);
+                if (stepId === undefined ||
+                    policy === undefined ||
+                    entry.aggregate_path === undefined ||
+                    entry.branches_completed === undefined ||
+                    entry.branches_failed === undefined) {
+                    break;
+                }
+                const title = stepTitle({ flow: input.flow, stepId });
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'fanout.joined',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: `Joined ${title}`,
+                    display: progressDisplay('Circuit: Finished comparing the options.', 'major', 'success'),
+                    presentation: replaceStatus(runId, `${stepId}:fanout`, 'Finished comparing the options.'),
+                    step_id: stepId,
+                    step_title: title,
+                    policy,
+                    aggregate_path: entry.aggregate_path,
+                    branches_completed: entry.branches_completed,
+                    branches_failed: entry.branches_failed,
+                    ...(entry.selected_branch_id === undefined
+                        ? {}
+                        : { selected_branch_id: entry.selected_branch_id }),
+                });
+                break;
+            }
+            case 'checkpoint.requested': {
+                const stepId = entry.step_id;
+                const allowedChoices = stringArrayValue(entry.options);
+                if (stepId === undefined ||
+                    entry.request_path === undefined ||
+                    allowedChoices === undefined) {
+                    break;
+                }
+                if (entry.auto_resolved !== false) {
+                    break;
+                }
+                const requestPath = checkpointRequestPath(input.runDir, entry.request_path);
+                taskStatuses.set(stepId, 'in_progress');
+                const title = stepTitle({ flow: input.flow, stepId });
+                const checkpointPromptText = checkpointPrompt(projectionFiles, requestPath);
+                const presentation = tournamentCheckpointPresentation({
+                    readJson: (path) => {
+                        try {
+                            const text = projectionFiles.readText(join(input.runDir, path));
+                            return text === undefined ? undefined : JSON.parse(text);
+                        }
+                        catch {
+                            return undefined;
+                        }
+                    },
+                    allowedChoices,
+                    fallbackPrompt: checkpointPromptText,
+                    fallbackLabel: checkpointChoiceLabel,
+                    fallbackDescription: (choice) => `Resume with '${choice}'.`,
+                });
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'checkpoint.waiting',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: `Waiting for checkpoint ${stepId}`,
+                    display: progressDisplay(`Circuit: Waiting for a checkpoint choice: ${presentation.choices
+                        .map((choice) => choice.label)
+                        .join(', ')}...`, 'major', 'checkpoint'),
+                    presentation: appendStatus(runId, 'Waiting for your choice...'),
+                    step_id: stepId,
+                    request_path: requestPath,
+                    allowed_choices: allowedChoices,
+                });
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'user_input.requested',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: 'Checkpoint choice requested',
+                    display: progressDisplay(presentation.prompt, 'major', 'checkpoint'),
+                    presentation: suppressStatus(runId),
+                    checkpoint: {
+                        step_id: stepId,
+                        request_path: requestPath,
+                        allowed_choices: allowedChoices,
+                    },
+                    questions: [
+                        {
+                            id: 'checkpoint-choice',
+                            header: 'Choice',
+                            question: presentation.prompt,
+                            options: presentation.choices.map((choice) => ({
+                                label: choice.label,
+                                description: choice.description,
+                                checkpoint_choice: choice.id,
+                            })),
+                            allow_free_text: false,
+                        },
+                    ],
+                    resume: {
+                        run_folder: input.runDir,
+                        checkpoint_choice_arg: '<choice>',
+                        command: `circuit resume --run-folder ${input.runDir} --checkpoint-choice <choice>`,
+                    },
+                });
+                reportTaskListProgress({
+                    progress: input.progress,
+                    runId,
+                    flowId,
+                    flow: input.flow,
+                    stepDisplayById,
+                    recordedAt,
+                    statuses: taskStatuses,
+                    label: `${title} waiting`,
+                    displayText: 'Circuit: Waiting for your choice...',
+                    tone: 'checkpoint',
+                });
+                break;
+            }
+            case 'step.completed': {
+                const stepId = entry.step_id;
+                if (stepId === undefined ||
+                    entry.attempt === undefined ||
+                    entry.route_taken === undefined) {
+                    break;
+                }
+                taskStatuses.set(stepId, 'completed');
+                const display = stepDisplay({ flow: input.flow, stepDisplayById, stepId });
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'step.completed',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: `Completed ${display.title}`,
+                    display: progressDisplay(`Finished ${display.activeText.toLowerCase()}.`, 'detail', 'success'),
+                    presentation: suppressStatus(runId),
+                    step_id: stepId,
+                    step_title: display.title,
+                    attempt: entry.attempt,
+                    route_taken: entry.route_taken,
+                });
+                reportTaskListProgress({
+                    progress: input.progress,
+                    runId,
+                    flowId,
+                    flow: input.flow,
+                    stepDisplayById,
+                    recordedAt,
+                    statuses: taskStatuses,
+                    label: `${display.title} completed`,
+                    displayText: `Finished ${display.activeText.toLowerCase()}.`,
+                    tone: 'success',
+                });
+                break;
+            }
+            case 'step.aborted': {
+                const stepId = entry.step_id;
+                if (stepId === undefined || entry.attempt === undefined || entry.reason === undefined) {
+                    break;
+                }
+                taskStatuses.set(stepId, 'failed');
+                const display = stepDisplay({ flow: input.flow, stepDisplayById, stepId });
+                reportProgress(input.progress, {
+                    schema_version: 1,
+                    type: 'step.aborted',
+                    run_id: runId,
+                    flow_id: flowId,
+                    recorded_at: recordedAt,
+                    label: `Aborted ${display.title}`,
+                    display: progressDisplay(`Circuit: Aborted ${display.title}: ${entry.reason}`, 'major', 'error'),
+                    presentation: appendStatus(runId, `Marked ${display.taskTitle} as failed.`),
+                    step_id: stepId,
+                    step_title: display.title,
+                    attempt: entry.attempt,
+                    reason: entry.reason,
+                });
+                reportTaskListProgress({
+                    progress: input.progress,
+                    runId,
+                    flowId,
+                    flow: input.flow,
+                    stepDisplayById,
+                    recordedAt,
+                    statuses: taskStatuses,
+                    label: `${display.title} failed`,
+                    displayText: `Circuit: Marked ${display.taskTitle} as failed.`,
+                    tone: 'error',
+                });
+                break;
+            }
+            case 'run.closed': {
+                const outcome = runOutcome(entry);
+                if (outcome === 'aborted') {
+                    const reason = runReason(entry);
+                    reportProgress(input.progress, {
+                        schema_version: 1,
+                        type: 'run.aborted',
+                        run_id: runId,
+                        flow_id: flowId,
+                        recorded_at: recordedAt,
+                        label: 'Circuit run aborted',
+                        display: progressDisplay(reason === undefined ? 'Circuit: Run aborted.' : `Circuit: Run aborted: ${reason}`, 'major', 'error'),
+                        presentation: appendStatus(runId, reason === undefined ? 'Run aborted.' : `Run aborted: ${reason}`),
+                        outcome,
+                        result_path: runResultPath(input.runDir),
+                        ...(reason === undefined ? {} : { reason }),
+                    });
+                }
+                else {
+                    reportProgress(input.progress, {
+                        schema_version: 1,
+                        type: 'run.completed',
+                        run_id: runId,
+                        flow_id: flowId,
+                        recorded_at: recordedAt,
+                        label: `Circuit run ${outcome}`,
+                        display: progressDisplay(`Circuit: Finished ${flowLabel(input.flow.id)}.`, 'major', 'success'),
+                        presentation: appendStatus(runId, `Finished ${flowLabel(input.flow.id)}.`),
+                        outcome,
+                        result_path: runResultPath(input.runDir),
+                    });
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    };
+}
+//# sourceMappingURL=progress.js.map