@zxyycom/vibe-check 0.0.1 → 0.0.2

package/src/project-run/check-execution/preflight.ts

@@ -7,6 +7,8 @@ import {
   type DiagnosticLogger
 } from "../diagnostic-logging/logger.ts";
 import { parseCheckPreflightResult, type ParsedCheckPreflightResult } from "./preflight-result.ts";
+import { invokeWithCapturedConsole } from "./console-capture.ts";
+import { combineCheckMessages } from "./messages.ts";
 
 const EMPTY_MESSAGES: readonly CheckMessage[] = Object.freeze([]);
 const INERT_SIGNAL = new AbortController().signal;
@@ -49,32 +51,10 @@ type PrepareCheckInput = Readonly<{
   readonly signal: AbortSignal | undefined;
 }>;
 
-type PreflightInvocation =
-  | Readonly<{ readonly kind: "returned"; readonly output: unknown }>
-  | Readonly<{ readonly kind: "threw"; readonly error: unknown }>;
+type PreflightInvocation = Awaited<ReturnType<typeof invokeWithCapturedConsole<unknown>>>;
 
-/** Completes the sequential invocation-wide barrier before any Check enters the Task graph. */
-export async function prepareChecks(
-  input: Readonly<{
-    readonly checks: readonly NormalizedCheck[];
-    readonly diagnosticLogger?: DiagnosticLogger;
-    readonly signal: AbortSignal | undefined;
-  }>
-): Promise<readonly CheckPreflightResolution[]> {
-  const resolutions: CheckPreflightResolution[] = [];
-  for (const check of input.checks) {
-    resolutions.push(
-      await prepareCheck({
-        check,
-        diagnosticLogger: input.diagnosticLogger,
-        signal: input.signal
-      })
-    );
-  }
-  return Object.freeze(resolutions);
-}
-
-async function prepareCheck(input: PrepareCheckInput): Promise<CheckPreflightResolution> {
+/** Resolves one Check's task-local preparation after Scheduler admission. */
+export async function prepareCheck(input: PrepareCheckInput): Promise<CheckPreflightResolution> {
   if (input.signal?.aborted) {
     return observeBlockedPreflight({
       check: input.check,
@@ -115,22 +95,25 @@ function resolvePreflightInvocation(
       check: input.check,
       diagnosticLogger: input.diagnosticLogger,
       details: { error: invocation.error },
+      messages: invocation.messages,
       result: input.signal?.aborted ? "cancelled-after-throw" : "threw",
       reasonCode: input.signal?.aborted ? "execution-cancelled" : "preflight-threw"
     });
   }
-  return resolveReturnedPreflight(input, invocation.output);
+  return resolveReturnedPreflight(input, invocation.output, invocation.messages);
 }
 
 function resolveReturnedPreflight(
   input: PrepareCheckInput,
-  preflightOutput: unknown
+  preflightOutput: unknown,
+  consoleMessages: readonly CheckMessage[]
 ): CheckPreflightResolution {
   if (input.signal?.aborted) {
     return observeBlockedPreflight({
       check: input.check,
       diagnosticLogger: input.diagnosticLogger,
       details: { raw: preflightOutput },
+      messages: consoleMessages,
       result: "cancelled-after-callback",
       reasonCode: "execution-cancelled"
     });
@@ -141,23 +124,25 @@ function resolveReturnedPreflight(
       check: input.check,
       diagnosticLogger: input.diagnosticLogger,
       details: { raw: preflightOutput },
+      messages: consoleMessages,
       result: "malformed",
       reasonCode: "invalid-preflight-result"
     });
   }
   if (preflightResult.status === "failure" && preflightResult.action === "block") {
-    return resolveBlockedPreflightResult(input, preflightResult);
+    return resolveBlockedPreflightResult(input, preflightResult, consoleMessages);
   }
-  return resolveReadyPreflightResult(input, preflightOutput, preflightResult);
+  return resolveReadyPreflightResult(input, preflightOutput, preflightResult, consoleMessages);
 }
 
 function resolveBlockedPreflightResult(
   input: PrepareCheckInput,
-  preflightResult: Extract<ParsedCheckPreflightResult, { readonly action: "block" }>
+  preflightResult: Extract<ParsedCheckPreflightResult, { readonly action: "block" }>,
+  consoleMessages: readonly CheckMessage[]
 ): CheckPreflightResolution {
   const resolution = blockedResolution({
     check: input.check,
-    messages: preflightResult.messages,
+    messages: combineCheckMessages(consoleMessages, preflightResult.messages),
     reasonCode: preflightResult.reason.code
   });
   observePreflightResolution(
@@ -176,13 +161,14 @@ function resolveBlockedPreflightResult(
 function resolveReadyPreflightResult(
   input: PrepareCheckInput,
   preflightOutput: unknown,
-  preflightResult: Exclude<ParsedCheckPreflightResult, { readonly action: "block" }>
+  preflightResult: Exclude<ParsedCheckPreflightResult, { readonly action: "block" }>,
+  consoleMessages: readonly CheckMessage[]
 ): CheckPreflightResolution {
   const checkId = input.check.definition.checkId;
   const result = preflightResult.status === "success" ? "prepared" : "continued";
   const resolution = readyResolution({
     authoredCheck: input.check,
-    messages: preflightResult.messages,
+    messages: combineCheckMessages(consoleMessages, preflightResult.messages),
     preparedOptions:
       preflightResult.status === "success"
         ? preflightResult.preparedOptions
@@ -200,14 +186,7 @@ async function invokePreflight(
   check: NormalizedCheck,
   signal: AbortSignal | undefined
 ): Promise<PreflightInvocation> {
-  try {
-    return Object.freeze({
-      kind: "returned",
-      output: await check.preflight!(check.options, signal ?? INERT_SIGNAL)
-    });
-  } catch (error) {
-    return Object.freeze({ kind: "threw", error });
-  }
+  return invokeWithCapturedConsole(() => check.preflight!(check.options, signal ?? INERT_SIGNAL));
 }
 
 function observeBlockedPreflight(
@@ -215,13 +194,14 @@ function observeBlockedPreflight(
     readonly check: NormalizedCheck;
     readonly diagnosticLogger: DiagnosticLogger | undefined;
     readonly details: Readonly<Record<string, unknown>>;
+    readonly messages?: readonly CheckMessage[];
     readonly result: PreflightResolutionResult;
     readonly reasonCode: string;
   }>
 ): BlockedCheckPreflightResolution {
   const resolution = blockedResolution({
     check: input.check,
-    messages: EMPTY_MESSAGES,
+    messages: input.messages ?? EMPTY_MESSAGES,
     reasonCode: input.reasonCode
   });
   observePreflightResolution(
@@ -284,7 +264,7 @@ function readyResolution(
   if (preparedOptions === undefined) {
     return blockedResolution({
       check: input.authoredCheck,
-      messages: EMPTY_MESSAGES,
+      messages: input.messages,
       reasonCode: "invalid-preflight-result"
     });
   }

package/src/project-run/check-execution/resolved-checks.ts

@@ -1,90 +1,96 @@
+import type { CheckMessage, CheckProjectContext } from "../../check/check.ts";
 import type {
-  CheckMessage,
-  CheckOutcome,
-  CheckProjectContext,
-  CheckVisibility
-} from "../../check/check.ts";
-import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
-import { createCoreCheckSession, type CoreCheckSession } from "../../check-settlement/session.ts";
+  NormalizedCheck,
+  SchedulerMeasurementHook
+} from "../../project-definition/project-definition.ts";
+import type { ResourceUnitMapping } from "../../project-definition/resource-unit-mapping.ts";
+import { createCoreCheckSession } from "../../check-settlement/session.ts";
 import {
   diagnosticTags,
   summarizeDiagnosticValue,
   type DiagnosticLogger
 } from "../diagnostic-logging/logger.ts";
 import { prepareTaskGraph } from "../task-scheduler/graph.ts";
+import type { AdmissionSelectionPolicy } from "../task-scheduler/admission-selection-policy.ts";
 import { runTaskGraph } from "../task-scheduler/scheduler.ts";
+import type { SchedulerPerformanceDiagnosticsInput } from "../task-scheduler/measurement/diagnostics.ts";
 import { executeCheckCallback } from "./callback.ts";
+import { artifactDirectoryForCheck, type ResolvedInvocationPaths } from "../invocation/paths.ts";
+import { runWithCheckConsoleRouter } from "./console-capture.ts";
 import { createCheckDependencies } from "./dependencies.ts";
 import {
   CheckExecutionInvariantFailure,
   recordSettledCheck,
   settleCallback,
-  type CheckExecutionSettlementState,
+  type CheckExecutionState,
   type CheckIdentity,
   type SettledCheckFacts
 } from "./execution-settlement.ts";
 import {
   checkIdentity,
-  closeCancelledExecution,
   closeResolvedChecks,
+  settleBlockedDependent,
   trustedFailure
 } from "./execution-finalization.ts";
+import type { CheckExecutionLifecycle } from "./lifecycle.ts";
 import { planStaticCheckGraph } from "./plan.ts";
 import {
-  prepareChecks,
+  selectEffectiveCheckIds,
+  resolveFlagControlSettlements,
+  type FlagControlSettlement
+} from "./flag-controls.ts";
+import {
+  prepareCheck,
   type CheckPreflightResolution,
-  type PreparedCheck,
   type ReadyCheckPreflightResolution
 } from "./preflight.ts";
+import type { ResolvedCheckExecution } from "./resolved-execution-result.ts";
 
 const INERT_SIGNAL = new AbortController().signal;
-const SYSTEM_MONOTONIC_CLOCK: CheckExecutionClock = Object.freeze({ now: () => performance.now() });
-
-/** Private Run handoff for Check lifecycle presentation and accounting. */
-export type CheckExecutionLifecycle = Readonly<{
-  readonly started: (fact: CheckStartedFact) => void;
-  readonly settled: (fact: CheckSettledFact) => void;
-}>;
+const NO_CHECK_MESSAGES: readonly CheckMessage[] = Object.freeze([]);
+const DIRECT_EXECUTION_INVOCATION_ID = "invocation/v1:direct-check-execution";
+const SYSTEM_MONOTONIC_CLOCK: CheckExecutionClock = Object.freeze({
+  now: () => performance.now()
+});
 
 /** Package-private monotonic clock seam for execution accounting. */
 export type CheckExecutionClock = Readonly<{ now(): number }>;
 
-export type CheckStartedFact = Readonly<{ checkId: string; displayName: string }>;
-
-export type CheckSettledFact = CheckStartedFact &
-  Readonly<{
-    durationMs: number | null;
-    messages: readonly CheckMessage[];
-    outcome: CheckOutcome;
-    visibility: CheckVisibility;
-  }>;
-
-type ResolvedCheckExecutionFacts = Readonly<{
-  readonly checkDurations: readonly import("../result.ts").CheckDuration[];
-  readonly checkMessages: readonly import("../result.ts").CheckRunMessage[];
-  readonly snapshot: import("../../check-settlement/facts.ts").CoreSnapshot;
-}>;
-
-export type ResolvedCheckExecution =
-  | (Readonly<{ readonly kind: "completed" }> & ResolvedCheckExecutionFacts)
-  | (Readonly<{ readonly kind: "cancelled" }> & ResolvedCheckExecutionFacts);
-
-export interface CheckExecutionState extends CheckExecutionSettlementState {
-  readonly session: CoreCheckSession;
-}
-
 interface ExecuteCheckInput extends CheckExecutionState {
-  readonly preflight: ReadyCheckPreflightResolution;
+  readonly check: NormalizedCheck;
   readonly clock: CheckExecutionClock;
+  readonly onAdmittedCheck: ((check: NormalizedCheck) => void) | undefined;
+  readonly invocationId: string;
+  readonly paths: ResolvedInvocationPaths | undefined;
   readonly project: CheckProjectContext;
   readonly signal: AbortSignal;
 }
 
-type PreparedResolvedCheckExecution = Readonly<{
-  readonly blockedCheckIds: ReadonlySet<string>;
-  readonly readyChecks: readonly PreparedCheck[];
-  readonly readyPreflights: readonly ReadyCheckPreflightResolution[];
-  readonly state: CheckExecutionState;
+type ResolvedCheckExecutionInput = Readonly<{
+  /** Complete prepared private policy handoff; public policy dispatch stays outside execution. */
+  readonly admissionPolicy?: AdmissionSelectionPolicy;
+  readonly checks: readonly NormalizedCheck[];
+  readonly maxParallel: number;
+  readonly resourceCapacities?: ResourceUnitMapping;
+  /** Product invocation identity；private direct-execution tests 使用稳定 fallback。 */
+  readonly invocationId?: string;
+  /** 冻结的 invocation paths；仅 private direct-execution tests 可以省略。 */
+  readonly paths?: ResolvedInvocationPaths;
+  readonly project: CheckProjectContext;
+  readonly signal: AbortSignal | undefined;
+  readonly clock?: CheckExecutionClock;
+  /** Core-owner Check lifecycle channel. */
+  readonly diagnosticLogger?: DiagnosticLogger;
+  /** Scheduler-owner decision and summary channel. */
+  readonly schedulerDiagnosticLogger?: DiagnosticLogger;
+  /** Explicit enabled-only diagnostics handoff from the invocation output owner. */
+  readonly schedulerPerformanceDiagnostics?: SchedulerPerformanceDiagnosticsInput;
+  readonly schedulerMeasurementHooks?: readonly SchedulerMeasurementHook[];
+  readonly onSchedulerMeasurementHookFailure?: () => void;
+  readonly onSchedulerMeasurementHooksSettled?: () => void;
+  readonly lifecycle?: CheckExecutionLifecycle;
+  /** Provider-owned bounded learned admission diagnostics, delivered by invocation. */
+  readonly onAdmittedCheck?: (check: NormalizedCheck) => void;
 }>;
 
 /**
@@ -92,48 +98,75 @@ type PreparedResolvedCheckExecution = Readonly<{
  * Task per Check. Graph validation happens before Core scopes or callbacks.
  */
 export async function executeResolvedChecks(
-  input: Readonly<{
-    readonly checks: readonly NormalizedCheck[];
-    readonly maxParallel: number;
-    readonly project: CheckProjectContext;
-    readonly signal: AbortSignal | undefined;
-    readonly clock?: CheckExecutionClock;
-    readonly diagnosticLogger?: DiagnosticLogger;
-    readonly lifecycle?: CheckExecutionLifecycle;
-  }>
+  input: ResolvedCheckExecutionInput
 ): Promise<ResolvedCheckExecution> {
-  const prepared = await prepareResolvedCheckExecution(input);
-  // The barrier is execution-phase work. A signal received while it runs must close this
-  // phase as cancelled even when every preflight already blocked and the scheduler graph is empty.
-  if (input.signal?.aborted) {
-    return closeCancelledExecution({
-      normalizedChecks: input.checks,
-      preparedChecks: prepared.readyChecks,
-      state: prepared.state
-    });
+  prepareTaskGraph(planStaticCheckGraph(input.checks, input.resourceCapacities), input.maxParallel);
+  const effectiveCheckIds = selectEffectiveCheckIds(input.checks, input.project.flags);
+  return runWithCheckConsoleRouter(() => executePreparedResolvedChecks(input, effectiveCheckIds));
+}
+
+async function executePreparedResolvedChecks(
+  input: ResolvedCheckExecutionInput,
+  effectiveCheckIds: readonly string[]
+): Promise<ResolvedCheckExecution> {
+  const state = createExecutionState({
+    checks: input.checks,
+    diagnosticLogger: input.diagnosticLogger,
+    lifecycle: input.lifecycle
+  });
+  const flagControlSettlements = resolveFlagControlSettlements({
+    checks: input.checks,
+    diagnosticLogger: input.diagnosticLogger,
+    effectiveCheckIds,
+    signal: input.signal
+  });
+  for (const settlement of flagControlSettlements) {
+    settleFlagControlOutcome(state, settlement);
   }
-  const readyPreflightByCheckId = new Map(
-    prepared.readyPreflights.map((preflight) => [preflight.check.definition.checkId, preflight])
+  input.lifecycle?.flagControlCompleted();
+  const checksByCheckId = new Map(
+    input.checks.map((check) => [check.definition.checkId, check] as const)
   );
-  const graph = planStaticCheckGraph(prepared.readyChecks, {
-    alreadySettledCheckIds: prepared.blockedCheckIds
-  });
-  let graphRun: Awaited<ReturnType<typeof runTaskGraph<void>>>;
+  let graphRun: Awaited<ReturnType<typeof runTaskGraph<boolean>>>;
   try {
-    graphRun = await runTaskGraph({
-      graph,
+    graphRun = await runTaskGraph<boolean>({
+      graph: planStaticCheckGraph(input.checks, input.resourceCapacities),
+      admissionPolicy: input.admissionPolicy,
       maxParallel: input.maxParallel,
-      diagnosticLogger: input.diagnosticLogger,
+      diagnosticLogger: input.schedulerDiagnosticLogger ?? input.diagnosticLogger,
+      performanceDiagnostics: input.schedulerPerformanceDiagnostics,
+      measurementHooks: input.schedulerMeasurementHooks,
+      onMeasurementHookFailure: input.onSchedulerMeasurementHookFailure,
+      onMeasurementHooksSettled: input.onSchedulerMeasurementHooksSettled,
+      preAdmissionTaskResults: Object.freeze(
+        flagControlSettlements.map((settlement) =>
+          Object.freeze({
+            taskId: settlement.check.definition.checkId,
+            value: false
+          })
+        )
+      ),
       signal: input.signal,
+      isPrerequisiteSatisfied: (satisfied) => satisfied,
+      onTaskBlocked: (task, dependencyIds) => {
+        const check = checksByCheckId.get(task.id);
+        if (check === undefined) {
+          throw new CheckExecutionInvariantFailure("Blocked Task has no normalized Check");
+        }
+        settleBlockedDependent({ check, dependencyIds, state });
+      },
       execute: (task, context) => {
-        const preflight = readyPreflightByCheckId.get(task.id);
-        if (preflight === undefined) {
-          throw new CheckExecutionInvariantFailure("Task graph has no prepared Check");
+        const check = checksByCheckId.get(task.id);
+        if (check === undefined) {
+          throw new CheckExecutionInvariantFailure("Task graph has no normalized Check");
         }
-        return executeCheck({
-          ...prepared.state,
-          preflight,
+        return executeAdmittedCheck({
+          ...state,
+          check,
           clock: input.clock ?? SYSTEM_MONOTONIC_CLOCK,
+          onAdmittedCheck: input.onAdmittedCheck,
+          invocationId: input.invocationId ?? DIRECT_EXECUTION_INVOCATION_ID,
+          paths: input.paths,
           project: input.project,
           signal: context.signal ?? INERT_SIGNAL
         });
@@ -145,34 +178,10 @@ export async function executeResolvedChecks(
 
   return closeResolvedChecks({
     allChecks: input.checks,
+    effectiveCheckIds,
     graphRun,
-    readyChecks: prepared.readyChecks,
-    state: prepared.state
-  });
-}
-
-async function prepareResolvedCheckExecution(
-  input: Readonly<{
-    readonly checks: readonly NormalizedCheck[];
-    readonly diagnosticLogger?: DiagnosticLogger;
-    readonly lifecycle?: CheckExecutionLifecycle;
-    readonly maxParallel: number;
-    readonly signal: AbortSignal | undefined;
-  }>
-): Promise<PreparedResolvedCheckExecution> {
-  prepareTaskGraph(planStaticCheckGraph(input.checks), input.maxParallel);
-  const preflights = await prepareChecks({
-    checks: input.checks,
-    diagnosticLogger: input.diagnosticLogger,
-    signal: input.signal
-  });
-  const state = createExecutionState({
-    checks: input.checks,
-    diagnosticLogger: input.diagnosticLogger,
-    lifecycle: input.lifecycle
+    state
   });
-  const partition = settlePreflightResolutions(state, preflights);
-  return Object.freeze({ ...partition, state });
 }
 
 function createExecutionState(
@@ -192,24 +201,19 @@ function createExecutionState(
   };
 }
 
-function settlePreflightResolutions(
+function settleFlagControlOutcome(
   state: CheckExecutionState,
-  resolutions: readonly CheckPreflightResolution[]
-): Omit<PreparedResolvedCheckExecution, "state"> {
-  const readyPreflights: ReadyCheckPreflightResolution[] = [];
-  const blockedCheckIds = new Set<string>();
-  for (const resolution of resolutions) {
-    if (resolution.kind === "ready") {
-      readyPreflights.push(resolution);
-      continue;
-    }
-    blockedCheckIds.add(resolution.check.definition.checkId);
-    settleBlockedPreflight(state, resolution);
-  }
-  return Object.freeze({
-    blockedCheckIds,
-    readyChecks: Object.freeze(readyPreflights.map((preflight) => preflight.check)),
-    readyPreflights: Object.freeze(readyPreflights)
+  settlement: FlagControlSettlement
+): void {
+  const scope = state.session.openCheckScope(settlement.check.definition.checkId);
+  const outcome = scope.settleProduct(settlement.outcome);
+  recordSettledCheck({
+    check: checkIdentity(settlement.check),
+    durationMs: null,
+    messages: NO_CHECK_MESSAGES,
+    outcome,
+    phase: "control",
+    state
   });
 }
 
@@ -229,7 +233,32 @@ function settleBlockedPreflight(
   });
 }
 
-async function executeCheck(input: ExecuteCheckInput): Promise<void> {
+async function executeAdmittedCheck(input: ExecuteCheckInput): Promise<boolean> {
+  observeAdmittedCheck(input);
+  const preflight = await prepareCheck({
+    check: input.check,
+    diagnosticLogger: input.diagnosticLogger,
+    signal: input.signal
+  });
+  if (preflight.kind === "blocked") {
+    settleBlockedPreflight(input, preflight);
+    return false;
+  }
+  return executeReadyCheck({ ...input, preflight });
+}
+
+/** Diagnostic observation belongs to the invocation; it cannot revise admitted Task facts. */
+function observeAdmittedCheck(input: ExecuteCheckInput): void {
+  try {
+    input.onAdmittedCheck?.(input.check);
+  } catch {
+    // Learned diagnostic output is best-effort and has no execution consequence.
+  }
+}
+
+async function executeReadyCheck(
+  input: ExecuteCheckInput & Readonly<{ readonly preflight: ReadyCheckPreflightResolution }>
+): Promise<boolean> {
   const check = input.preflight.check;
   const checkId = check.definition.checkId;
   const scope = input.session.openCheckScope(checkId);
@@ -246,14 +275,17 @@ async function executeCheck(input: ExecuteCheckInput): Promise<void> {
   emitStarted(input.lifecycle, identity);
   const startedAt = input.clock.now();
   const callback = await executeCheckCallback({
+    artifactDirectory:
+      input.paths === undefined ? null : artifactDirectoryForCheck(input.paths, checkId),
     check,
     dependencies: createCheckDependencies({
       checkId,
       diagnosticLogger: input.diagnosticLogger,
-      directDependencyIds: check.dependsOn,
+      directRelationCheckIds: directRelationCheckIds(check),
       session: input.session
     }),
     diagnosticLogger: input.diagnosticLogger,
+    invocationId: input.invocationId,
     project: input.project,
     scope,
     signal: input.signal
@@ -273,6 +305,13 @@ async function executeCheck(input: ExecuteCheckInput): Promise<void> {
     phase: "execution",
     state: input
   });
+  return settled.outcome.status === "passed";
+}
+
+function directRelationCheckIds(
+  check: Pick<NormalizedCheck, "dependsOn" | "observes">
+): readonly string[] {
+  return Object.freeze([...new Set([...check.dependsOn, ...check.observes])].sort());
 }
 
 function emitStarted(lifecycle: CheckExecutionLifecycle | undefined, check: CheckIdentity): void {

package/src/project-run/check-execution/resolved-execution-result.ts

@@ -0,0 +1,22 @@
+import type { CoreSnapshot } from "../../check-settlement/facts.ts";
+import type { SchedulerMeasurementContext } from "../../project-definition/project-definition.ts";
+import type { CheckDuration, CheckRunMessage } from "../result.ts";
+
+type ResolvedCheckExecutionFacts = Readonly<{
+  readonly checkDurations: readonly CheckDuration[];
+  readonly checkMessages: readonly CheckRunMessage[];
+  readonly snapshot: CoreSnapshot;
+  /** Product-private terminal Scheduler facts; never projected into RunResult. */
+  readonly terminalSchedulerMeasurement?: SchedulerMeasurementContext;
+}>;
+
+/** Private terminal result passed from Check execution to the invocation boundary. */
+export type ResolvedCheckExecution =
+  | (Readonly<{
+      /** Private effective selection shared with invocation-level aggregation. */
+      readonly effectiveCheckIds: readonly string[];
+      readonly kind: "completed";
+    }> &
+      ResolvedCheckExecutionFacts)
+  | (Readonly<{ readonly kind: "cancelled" }> & ResolvedCheckExecutionFacts)
+  | (Readonly<{ readonly kind: "admission-policy-failed" }> & ResolvedCheckExecutionFacts);