@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-run/invocation/paths.ts

@@ -0,0 +1,154 @@
+import { createHash } from "node:crypto";
+import { join, relative, resolve } from "node:path";
+
+import type { DiagnosticChannel } from "../diagnostic-logging/logger.ts";
+import type { DiagnosticLogFileNaming } from "../controls/contract.ts";
+
+import type { ProjectOutputs } from "../../project-definition/project-definition.ts";
+
+/**
+ * Invocation owner 的 absolute paths；刻意排除 caller-owned cross-Run state、cache storage 和
+ * external-tool workspace。
+ */
+export type ResolvedInvocationPaths = Readonly<{
+  /** Check-local absolute directories；保持私有，避免披露 sibling capability。 */
+  readonly checkArtifactDirectories: readonly ResolvedCheckArtifactDirectory[];
+  /** caller 选择的 Check-owned invocation artifact absolute base；未配置时为 `null`。 */
+  readonly checkArtifactBaseDirectory: string | null;
+  /** 按 owner channel 分开的 diagnostic absolute targets。 */
+  readonly diagnosticLoggingFiles: Readonly<Record<DiagnosticChannel, string | null>>;
+  /** 按既有 RunResult-relative contract 投影的 diagnostic channel files。 */
+  readonly diagnosticLoggingReadbackFiles: Readonly<Record<DiagnosticChannel, string | null>>;
+  /** 本次 invocation 的 machine publisher absolute target。 */
+  readonly machinePublicationDirectory: string;
+  /** caller 为本 Run 指定的 progress transcript target；不设置则只保留 terminal。 */
+  readonly progressLogFile: string | null;
+  /** 每个 callback 共享的 absolute effective project root。 */
+  readonly projectRoot: string;
+}>;
+
+/** 在任何 author callback 前恰好一次解析全部 Product-owned invocation target。 */
+export function resolveInvocationPaths(
+  input: Readonly<{
+    readonly checkArtifactBaseDirectory: string | undefined;
+    readonly checkIds: readonly string[];
+    readonly diagnosticLogFileNaming: DiagnosticLogFileNaming;
+    readonly diagnosticLogSuffix: string | undefined;
+    readonly outputConfiguration: ProjectOutputs;
+    readonly progressLogFile: string | undefined;
+    readonly projectRoot: string;
+  }>
+): ResolvedInvocationPaths {
+  const projectRoot = resolve(input.projectRoot);
+  const checkArtifactBaseDirectory =
+    input.checkArtifactBaseDirectory === undefined
+      ? null
+      : resolve(projectRoot, input.checkArtifactBaseDirectory);
+  const diagnosticDirectory = resolve(
+    projectRoot,
+    input.outputConfiguration.diagnosticLogging.directory
+  );
+  const diagnosticLoggingFiles = diagnosticFilesFor({
+    diagnosticDirectory,
+    diagnosticLogFileNaming: input.diagnosticLogFileNaming,
+    diagnosticLogSuffix: input.diagnosticLogSuffix
+  });
+  const machinePublicationDirectory = resolve(
+    projectRoot,
+    input.outputConfiguration.machinePublication.directory
+  );
+
+  return Object.freeze({
+    checkArtifactDirectories: resolveCheckArtifactDirectories(
+      checkArtifactBaseDirectory,
+      input.checkIds
+    ),
+    checkArtifactBaseDirectory,
+    diagnosticLoggingFiles,
+    diagnosticLoggingReadbackFiles: diagnosticReadbackFiles(projectRoot, diagnosticLoggingFiles),
+    machinePublicationDirectory,
+    progressLogFile:
+      input.progressLogFile === undefined ? null : resolve(projectRoot, input.progressLogFile),
+    projectRoot
+  });
+}
+
+function diagnosticFilesFor(
+  input: Readonly<{
+    readonly diagnosticDirectory: string;
+    readonly diagnosticLogFileNaming: DiagnosticLogFileNaming;
+    readonly diagnosticLogSuffix: string | undefined;
+  }>
+): Readonly<Record<DiagnosticChannel, string | null>> {
+  const file = (channel: DiagnosticChannel): string | null => {
+    if (input.diagnosticLogSuffix === undefined) return null;
+    const basename =
+      input.diagnosticLogFileNaming === "channel"
+        ? `${channel}.log`
+        : `${channel}-${input.diagnosticLogSuffix}.log`;
+    return join(input.diagnosticDirectory, basename);
+  };
+  return Object.freeze({
+    core: file("core"),
+    scheduler: file("scheduler")
+  });
+}
+
+function diagnosticReadbackFiles(
+  projectRoot: string,
+  files: Readonly<Record<DiagnosticChannel, string | null>>
+): Readonly<Record<DiagnosticChannel, string | null>> {
+  const readback = (channel: DiagnosticChannel): string | null => {
+    const file = files[channel];
+    return file === null ? null : relative(projectRoot, file);
+  };
+  return Object.freeze({
+    core: readback("core"),
+    scheduler: readback("scheduler")
+  });
+}
+
+type ResolvedCheckArtifactDirectory = Readonly<{
+  readonly checkId: string;
+  readonly directory: string;
+}>;
+
+/** 只返回当前 Check-local artifact directory，不向 callback 暴露 sibling directories。 */
+export function artifactDirectoryForCheck(
+  paths: ResolvedInvocationPaths,
+  checkId: string
+): string | null {
+  return (
+    paths.checkArtifactDirectories.find((entry) => entry.checkId === checkId)?.directory ?? null
+  );
+}
+
+function resolveCheckArtifactDirectories(
+  checkArtifactBaseDirectory: string | null,
+  checkIds: readonly string[]
+): readonly ResolvedCheckArtifactDirectory[] {
+  if (checkArtifactBaseDirectory === null) return Object.freeze([]);
+
+  const directories: ResolvedCheckArtifactDirectory[] = [];
+  const checkIdByEncodedDirectory = new Map<string, string>();
+  for (const checkId of checkIds) {
+    const encodedDirectory = encodeCheckArtifactDirectory(checkId);
+    const priorCheckId = checkIdByEncodedDirectory.get(encodedDirectory);
+    if (priorCheckId !== undefined && priorCheckId !== checkId) {
+      throw new Error("Distinct Check IDs resolved to one artifact directory");
+    }
+    checkIdByEncodedDirectory.set(encodedDirectory, checkId);
+    directories.push(
+      Object.freeze({ checkId, directory: join(checkArtifactBaseDirectory, encodedDirectory) })
+    );
+  }
+  return Object.freeze(directories);
+}
+
+/**
+ * SHA-256 base64url component 不包含分隔符或 traversal token，且远低于常规 filesystem component length。
+ * raw Check ID 仍由既有 facts 保存。
+ */
+function encodeCheckArtifactDirectory(checkId: string): string {
+  return `check-${createHash("sha256").update(checkId, "utf8").digest("base64url")}`;
+}

package/src/project-run/invocation/progress.ts

@@ -0,0 +1,38 @@
+import type { CoreSnapshot } from "../../check-settlement/facts.ts";
+import type { CheckExecutionClock } from "../check-execution/resolved-checks.ts";
+
+/** Forms the terminal progress counters without changing Core Check facts. */
+export function outcomeCounts(snapshot: CoreSnapshot): Readonly<{
+  readonly failed: number;
+  readonly notApplicable: number;
+  readonly passed: number;
+  readonly unavailable: number;
+}> {
+  let failed = 0;
+  let notApplicable = 0;
+  let passed = 0;
+  let unavailable = 0;
+  for (const check of snapshot.checks) {
+    switch (check.outcome.status) {
+      case "passed":
+        passed += 1;
+        break;
+      case "failed":
+        failed += 1;
+        break;
+      case "not-applicable":
+        notApplicable += 1;
+        break;
+      case "unavailable":
+        unavailable += 1;
+        break;
+    }
+  }
+  return Object.freeze({ failed, notApplicable, passed, unavailable });
+}
+
+/** Converts the invocation monotonic clock into a safe progress duration. */
+export function elapsedSince(startedAt: number, clock: CheckExecutionClock): number {
+  const elapsed = clock.now() - startedAt;
+  return Number.isFinite(elapsed) && elapsed >= 0 ? elapsed : 0;
+}

package/src/project-run/invocation/run.ts

@@ -0,0 +1,144 @@
+import {
+  normalizeProjectDefinition,
+  type DefinitionWarning,
+  type NormalizedProjectDefinition,
+  type ProjectDefinition,
+  type ResolvedProjectOutputs
+} from "../../project-definition/project-definition.ts";
+import type { CheckAggregation, RunControls } from "../controls/contract.ts";
+import type { AdmissionStrategyProviderFactory } from "../admission-strategy-provider/provider.ts";
+import { prepareTaskGraph } from "../task-scheduler/graph.ts";
+import { CheckAggregationFailure } from "../aggregation.ts";
+import { type CheckExecutionClock } from "../check-execution/resolved-checks.ts";
+import { planStaticCheckGraph } from "../check-execution/plan.ts";
+import {
+  type ProgressRefreshScheduler,
+  type ProgressRendering,
+  type ProgressWriterFactory
+} from "../progress-rendering/presentation.ts";
+import { closeAggregationFailure, finalizeInvocation } from "../completion/completion.ts";
+import type { ResolvedInvocationPaths } from "./paths.ts";
+import type { OutputStatuses } from "../outputs/status.ts";
+import { isCancelled, type NonConfigurationRunResult, type RunResult } from "../result.ts";
+import {
+  diagnosticTags,
+  summarizeDiagnosticValue,
+  type DiagnosticLoggerFactory,
+  type DiagnosticLoggingRouter
+} from "../diagnostic-logging/logger.ts";
+import { createInvocation } from "./creation.ts";
+import { cancelledBeforeExecution, executionResult, planningResult } from "./candidates.ts";
+import { executePlannedInvocation } from "./execution.ts";
+export type Invocation = Readonly<{
+  /** Product-private test seam; package `run` never accepts a provider factory. */
+  readonly admissionStrategyProviderFactory: AdmissionStrategyProviderFactory | undefined;
+  readonly clock: CheckExecutionClock;
+  readonly controls: RunControls;
+  readonly declarativeFingerprint: string;
+  readonly definition: ProjectDefinition;
+  readonly definitionWarnings: readonly DefinitionWarning[];
+  readonly diagnosticLogging: DiagnosticLoggingRouter;
+  /** Effective output selection, retained privately for enabled-only Scheduler diagnostics. */
+  readonly diagnosticLoggingEnabled: boolean;
+  readonly outputConfiguration: ResolvedProjectOutputs;
+  readonly outputs: OutputStatuses;
+  readonly invocationId: string;
+  readonly normalized: NormalizedProjectDefinition;
+  /** 本次 invocation 冻结的 Product-private output 与 Check artifact paths。 */
+  readonly paths: ResolvedInvocationPaths;
+  readonly progressRendering: ProgressRendering;
+  /** Immutable UTC instant captured for enabled diagnostic or machine output, otherwise `null`. */
+  readonly startedAtUtc: string | null;
+}>;
+export interface RunInvocationDependencies {
+  /** Product-private test seam for proving invocation lifecycle sequencing. */
+  readonly admissionStrategyProviderFactory?: AdmissionStrategyProviderFactory;
+  readonly clock?: CheckExecutionClock;
+  readonly progressRefreshScheduler?: ProgressRefreshScheduler;
+  readonly progressWriterFactory?: ProgressWriterFactory;
+  readonly diagnosticLoggerFactory?: DiagnosticLoggerFactory;
+  /** Test seam for the invocation's machine-readable wall-clock timestamp. */
+  readonly wallClock?: Readonly<{ now(): Date }>;
+}
+
+export async function executeValidatedRun(
+  definition: ProjectDefinition,
+  controls: RunControls,
+  definitionWarnings: readonly DefinitionWarning[],
+  dependencies: RunInvocationDependencies = {}
+): Promise<RunResult> {
+  const normalized = normalizeProjectDefinition(definition);
+  const invocation = createInvocation({
+    controls,
+    definition,
+    definitionWarnings,
+    dependencies,
+    normalized
+  });
+  let candidate: NonConfigurationRunResult;
+  try {
+    observeInvocationStarted(invocation, controls.checkAggregation);
+    if (isCancelled(controls)) {
+      candidate = cancelledBeforeExecution(invocation, "pre-work");
+    } else if (!validateTaskGraph(invocation)) {
+      candidate = planningResult(invocation, "task-graph-invalid");
+    } else {
+      candidate = await executePlannedInvocation(invocation, controls.checkAggregation);
+    }
+  } catch (error) {
+    if (error instanceof CheckAggregationFailure) {
+      closeAggregationFailure(invocation);
+      throw error.originalError;
+    }
+    candidate = executionResult(invocation, "task-engine-failed");
+  }
+  return finalizeInvocation(invocation, candidate);
+}
+
+function observeInvocationStarted(
+  invocation: Invocation,
+  aggregation: CheckAggregation | undefined
+): void {
+  invocation.diagnosticLogging.core.observe({
+    event: "run.started",
+    tags: diagnosticTags("RUN", "STARTED"),
+    details: {
+      aggregation: aggregation === undefined ? "default" : "custom",
+      checkCount: invocation.normalized.checks.length,
+      flags: summarizeDiagnosticValue(invocation.controls.flags ?? []),
+      outputs: invocation.outputConfiguration,
+      scheduler: invocation.normalized.declarative.scheduler
+    }
+  });
+}
+
+function validateTaskGraph(invocation: Invocation): boolean {
+  try {
+    prepareTaskGraph(
+      planStaticCheckGraph(
+        invocation.normalized.checks,
+        invocation.normalized.declarative.scheduler.resourceCapacities
+      ),
+      invocation.normalized.declarative.scheduler.maxParallel
+    );
+    invocation.diagnosticLogging.core.observe({
+      event: "run.planning.succeeded",
+      tags: diagnosticTags("RUN", "PLANNING", "SUCCEEDED"),
+      details: {
+        checkCount: invocation.normalized.checks.length,
+        maxParallel: invocation.normalized.declarative.scheduler.maxParallel
+      }
+    });
+    return true;
+  } catch {
+    invocation.diagnosticLogging.core.observe({
+      event: "run.planning.failed",
+      tags: diagnosticTags("RUN", "PLANNING", "FAILED"),
+      details: {
+        checkCount: invocation.normalized.checks.length,
+        maxParallel: invocation.normalized.declarative.scheduler.maxParallel
+      }
+    });
+    return false;
+  }
+}

package/src/project-run/invocation/scheduler.ts

@@ -0,0 +1,82 @@
+import type { CheckProjectContext } from "../../check/check.ts";
+import type { PreparedAdmissionStrategy } from "../admission-strategy-provider/prepared-admission-strategy.ts";
+import { executeResolvedChecks } from "../check-execution/resolved-checks.ts";
+import type { ResolvedCheckExecution } from "../check-execution/resolved-execution-result.ts";
+import type { Invocation } from "./run.ts";
+import type { NonConfigurationRunResult } from "../result.ts";
+
+export type SchedulerExecution =
+  | ResolvedCheckExecution
+  | Extract<NonConfigurationRunResult, { readonly kind: "execution" }>;
+
+type SchedulerAdapterInput = Readonly<{
+  readonly invocation: Invocation;
+  readonly preparedStrategy: PreparedAdmissionStrategy;
+  readonly project: CheckProjectContext;
+}>;
+
+/** Bridges one prepared invocation to resolved Check execution and contains task-engine faults. */
+export async function executeScheduler(input: SchedulerAdapterInput): Promise<SchedulerExecution> {
+  const { invocation, preparedStrategy } = input;
+  try {
+    const performanceDiagnostics = schedulerPerformanceDiagnostics(input);
+    return await executeResolvedChecks({
+      admissionPolicy: preparedStrategy.admissionPolicy,
+      checks: invocation.normalized.checks,
+      clock: invocation.clock,
+      diagnosticLogger: invocation.diagnosticLogging.core,
+      ...(invocation.diagnosticLoggingEnabled
+        ? { schedulerDiagnosticLogger: invocation.diagnosticLogging.scheduler }
+        : {}),
+      ...(performanceDiagnostics === undefined
+        ? {}
+        : { schedulerPerformanceDiagnostics: performanceDiagnostics }),
+      schedulerTerminalEffects: invocation.normalized.scheduler.terminalEffects,
+      onSchedulerTerminalEffectFailure: () => {
+        invocation.outputs.failed("terminalEffects");
+      },
+      onSchedulerTerminalEffectsSettled: () => {
+        invocation.outputs.succeeded("terminalEffects");
+      },
+      maxParallel: invocation.normalized.declarative.scheduler.maxParallel,
+      resourceCapacities: invocation.normalized.declarative.scheduler.resourceCapacities,
+      invocationId: invocation.invocationId,
+      checkLifecycle: invocation.progressRendering.checkLifecycle,
+      invocationLifecycle: invocation.progressRendering.invocationLifecycle,
+      paths: invocation.paths,
+      project: input.project,
+      signal: invocation.controls.signal
+    });
+  } catch {
+    return taskEngineFailure(invocation);
+  }
+}
+
+function schedulerPerformanceDiagnostics(input: SchedulerAdapterInput) {
+  const { invocation, preparedStrategy } = input;
+  const shouldCollectSchedulerPerformanceDiagnostics =
+    invocation.diagnosticLoggingEnabled ||
+    invocation.normalized.scheduler.terminalEffects.length > 0 ||
+    preparedStrategy.admissionPolicy.requiresMeasurement === true ||
+    preparedStrategy.requiresTerminalMeasurement;
+  if (!shouldCollectSchedulerPerformanceDiagnostics) return undefined;
+  return Object.freeze({
+    clock: invocation.clock,
+    declarativeFingerprint: invocation.declarativeFingerprint,
+    ...(invocation.diagnosticLoggingEnabled
+      ? { logger: invocation.diagnosticLogging.scheduler }
+      : {})
+  });
+}
+
+function taskEngineFailure(
+  invocation: Invocation
+): Extract<NonConfigurationRunResult, { readonly kind: "execution" }> {
+  return Object.freeze({
+    kind: "execution",
+    declarativeFingerprint: invocation.declarativeFingerprint,
+    definitionWarnings: invocation.definitionWarnings,
+    diagnostic: Object.freeze({ code: "task-engine-failed" }),
+    outputs: invocation.outputs.value()
+  });
+}

package/src/project-run/{output-configuration.ts → outputs/configuration.ts}

@@ -1,18 +1,19 @@
 import type {
   ProjectDefinition,
-  ProjectOutputs
-} from "../project-definition/project-definition.ts";
-import type { RunControls } from "./controls/contract.ts";
+  ResolvedProjectOutputs
+} from "../../project-definition/project-definition.ts";
+import { resolveProgressRenderingOutput } from "../../project-definition/output-defaults.ts";
+import type { RunControls } from "../controls/contract.ts";
 export function effectiveOutputs(
   definition: ProjectDefinition,
   controls: RunControls
-): ProjectOutputs {
+): ResolvedProjectOutputs {
   return Object.freeze({
     machinePublication: Object.freeze({
       ...definition.outputs.machinePublication,
       ...controls.outputs?.machinePublication
     }),
-    progressRendering: Object.freeze({
+    progressRendering: resolveProgressRenderingOutput({
       ...definition.outputs.progressRendering,
       ...controls.outputs?.progressRendering
     }),

package/src/project-run/outputs/status.ts

@@ -0,0 +1,161 @@
+import type { ProjectOutputs } from "../../project-definition/project-definition.ts";
+import { DIAGNOSTIC_CHANNELS, type DiagnosticChannel } from "../diagnostic-logging/logger.ts";
+
+/** 一项 Run-owned terminal output 或 measurement participant 的最终状态 readback。 */
+export interface RunOutputStatus {
+  /** effective configuration 是否启用该 participant；`false` 时 status 必为 `disabled`。 */
+  readonly enabled: boolean;
+  /** `disabled` 为未启用；`not-run` 为启用但未到达完成；`succeeded` 为完成，`failed` 为其 own I/O 或 hook failure。 */
+  readonly status: "disabled" | "failed" | "not-run" | "succeeded";
+}
+
+/** Product-owned 人读 diagnostic channel；即使 setup 失败也保留其 file readback。 */
+export interface RunDiagnosticLoggingChannelStatus extends RunOutputStatus {
+  /**
+   * 相对 effective project root 的 target readback；跨卷时可为 absolute path。disabled channel 为 `null`，
+   * enabled channel 即使 setup 失败也保留预先计算的 path。
+   */
+  readonly file: string | null;
+}
+
+/** diagnostic logging aggregate 及其各 owner channel 的最终状态 readback。 */
+export interface RunDiagnosticLoggingOutputStatus extends RunOutputStatus {
+  /** aggregate status 及每个 owner channel 的独立 readback；partial failure 可由此定位。 */
+  readonly channels: Readonly<Record<DiagnosticChannel, RunDiagnosticLoggingChannelStatus>>;
+}
+
+/** 配置有效后四个 terminal output participant 的独立最终状态。 */
+export interface RunOutputStatuses {
+  /** `run.json` 与 `records.ndjson` canonical publication 的状态。 */
+  readonly machinePublication: RunOutputStatus;
+  /** terminal progress 与可选 progress log tee 的状态。 */
+  readonly progressRendering: RunOutputStatus;
+  /** core 与 scheduler diagnostic channels 的 aggregate 状态。 */
+  readonly diagnosticLogging: RunDiagnosticLoggingOutputStatus;
+  /**
+   * Definition generic effects 与 prepared custom strategy 的 optional `terminalEffect` 所形成的 terminal participant
+   * 状态；它不能由 RunControls 注入或覆盖。
+   */
+  readonly terminalEffects: RunOutputStatus;
+}
+
+export interface OutputStatuses {
+  /** Enables a runtime-only terminal participant after successful preparation. */
+  readonly enableTerminalEffects: () => void;
+  /** A diagnostic channel failure is isolated but updates the aggregate diagnostic output. */
+  readonly failedDiagnosticChannel: (channel: DiagnosticChannel) => void;
+  readonly failed: (output: keyof RunOutputStatuses) => void;
+  readonly succeededDiagnosticChannel: (channel: DiagnosticChannel) => void;
+  readonly succeeded: (output: keyof RunOutputStatuses) => void;
+  readonly value: () => RunOutputStatuses;
+}
+
+export function createOutputStatuses(
+  configuration: ProjectOutputs,
+  diagnosticLoggingFiles: Readonly<Record<DiagnosticChannel, string | null>>,
+  initialTerminalEffectsEnabled: boolean
+): OutputStatuses {
+  let terminalEffectsEnabled = initialTerminalEffectsEnabled;
+  const diagnosticChannelEnabled: Readonly<Record<DiagnosticChannel, boolean>> = Object.freeze({
+    core: configuration.diagnosticLogging.enabled,
+    scheduler: configuration.diagnosticLogging.enabled
+  });
+  const statuses: Record<keyof RunOutputStatuses, RunOutputStatus["status"]> = {
+    machinePublication: initialStatus(configuration.machinePublication.enabled),
+    progressRendering: initialStatus(configuration.progressRendering.enabled),
+    diagnosticLogging: initialStatus(configuration.diagnosticLogging.enabled),
+    terminalEffects: initialStatus(terminalEffectsEnabled)
+  };
+  const diagnosticChannelStatuses: Record<DiagnosticChannel, RunOutputStatus["status"]> = {
+    core: initialStatus(diagnosticChannelEnabled.core),
+    scheduler: initialStatus(diagnosticChannelEnabled.scheduler)
+  };
+  const enabled = (output: keyof RunOutputStatuses): boolean =>
+    output === "terminalEffects" ? terminalEffectsEnabled : configuration[output].enabled;
+  const refreshDiagnosticAggregate = (): void => {
+    const enabledStatuses = DIAGNOSTIC_CHANNELS.filter(
+      (channel) => diagnosticChannelEnabled[channel]
+    ).map((channel) => diagnosticChannelStatuses[channel]);
+    if (enabledStatuses.includes("failed")) {
+      statuses.diagnosticLogging = "failed";
+      return;
+    }
+    if (enabledStatuses.every((status) => status === "succeeded")) {
+      statuses.diagnosticLogging = "succeeded";
+      return;
+    }
+    statuses.diagnosticLogging = enabledStatuses.every((status) => status === "disabled")
+      ? "disabled"
+      : "not-run";
+  };
+  return Object.freeze({
+    enableTerminalEffects: () => {
+      if (terminalEffectsEnabled) return;
+      terminalEffectsEnabled = true;
+      statuses.terminalEffects = "not-run";
+    },
+    failedDiagnosticChannel: (channel: DiagnosticChannel) => {
+      if (!diagnosticChannelEnabled[channel]) return;
+      diagnosticChannelStatuses[channel] = "failed";
+      refreshDiagnosticAggregate();
+    },
+    failed: (output: keyof RunOutputStatuses) => {
+      if (enabled(output)) statuses[output] = "failed";
+    },
+    succeededDiagnosticChannel: (channel: DiagnosticChannel) => {
+      if (!diagnosticChannelEnabled[channel] || diagnosticChannelStatuses[channel] === "failed")
+        return;
+      diagnosticChannelStatuses[channel] = "succeeded";
+      refreshDiagnosticAggregate();
+    },
+    succeeded: (output: keyof RunOutputStatuses) => {
+      if (enabled(output) && statuses[output] !== "failed") statuses[output] = "succeeded";
+    },
+    value: () =>
+      Object.freeze({
+        machinePublication: Object.freeze({
+          enabled: configuration.machinePublication.enabled,
+          status: statuses.machinePublication
+        }),
+        progressRendering: Object.freeze({
+          enabled: configuration.progressRendering.enabled,
+          status: statuses.progressRendering
+        }),
+        diagnosticLogging: Object.freeze({
+          channels: Object.freeze({
+            core: diagnosticChannelValue("core"),
+            scheduler: diagnosticChannelValue("scheduler")
+          }),
+          enabled: configuration.diagnosticLogging.enabled,
+          status: statuses.diagnosticLogging
+        }),
+        terminalEffects: Object.freeze({
+          enabled: terminalEffectsEnabled,
+          status: statuses.terminalEffects
+        })
+      })
+  });
+
+  function diagnosticChannelValue(channel: DiagnosticChannel): RunDiagnosticLoggingChannelStatus {
+    return Object.freeze({
+      enabled: diagnosticChannelEnabled[channel],
+      file: diagnosticLoggingFiles[channel],
+      status: diagnosticChannelStatuses[channel]
+    });
+  }
+}
+
+export function failedOutput(statuses: RunOutputStatuses): keyof RunOutputStatuses | undefined {
+  for (const output of [
+    "progressRendering",
+    "machinePublication",
+    "diagnosticLogging",
+    "terminalEffects"
+  ] as const)
+    if (statuses[output].status === "failed") return output;
+  return undefined;
+}
+
+function initialStatus(enabled: boolean): RunOutputStatus["status"] {
+  return enabled ? "not-run" : "disabled";
+}