@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-run/check-execution/console-capture.ts

@@ -0,0 +1,262 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Console } from "node:console";
+import { Writable } from "node:stream";
+import { formatWithOptions } from "node:util";
+
+import type { CheckMessage, CheckMessageLevel } from "../../check/check.ts";
+
+type ConsoleInvocation<Result> = Readonly<
+  | {
+      readonly kind: "returned";
+      readonly output: Result;
+      readonly messages: readonly CheckMessage[];
+    }
+  | {
+      readonly kind: "threw";
+      readonly error: unknown;
+      readonly messages: readonly CheckMessage[];
+    }
+>;
+
+type ConsoleStream = "stderr" | "stdout";
+
+interface ActiveConsoleCall {
+  readonly chunks: Array<Readonly<{ readonly stream: ConsoleStream; readonly text: string }>>;
+  readonly method: string;
+}
+
+interface InstalledConsoleMethod {
+  readonly descriptor: PropertyDescriptor | undefined;
+  readonly method: string;
+}
+
+const HOST_CONSOLE = globalThis.console;
+const captureContext = new AsyncLocalStorage<CheckConsoleCapture>();
+let activeRouterOwnerCount = 0;
+let installedMethods: readonly InstalledConsoleMethod[] = Object.freeze([]);
+
+/** Installs one shared router around the complete resolved-Check execution lifecycle. */
+export async function runWithCheckConsoleRouter<Result>(
+  operation: () => Result | Promise<Result>
+): Promise<Result> {
+  const release = acquireConsoleRouter();
+  try {
+    return await operation();
+  } finally {
+    release();
+  }
+}
+
+/**
+ * Runs one author-owned Check function in an isolated console capture context. Concurrent contexts
+ * keep separate buffers; the resolved-Check lifecycle owns router installation and restoration.
+ */
+export async function invokeWithCapturedConsole<Result>(
+  operation: () => Result | Promise<Result>
+): Promise<ConsoleInvocation<Result>> {
+  const capture = new CheckConsoleCapture();
+  return captureContext.run(capture, async () => {
+    try {
+      const output = await operation();
+      return Object.freeze({ kind: "returned", messages: capture.snapshot(), output });
+    } catch (error) {
+      return Object.freeze({ kind: "threw", error, messages: capture.snapshot() });
+    }
+  });
+}
+
+class CheckConsoleCapture {
+  readonly #console: Console;
+  readonly #messages: CheckMessage[] = [];
+  #activeCall: ActiveConsoleCall | undefined;
+
+  public constructor() {
+    this.#console = new Console({
+      colorMode: false,
+      ignoreErrors: true,
+      stderr: this.#writer("stderr"),
+      stdout: this.#writer("stdout")
+    });
+  }
+
+  public invoke(method: string, arguments_: readonly unknown[]): void {
+    const activeCall: ActiveConsoleCall = { chunks: [], method };
+    const previousCall = this.#activeCall;
+    this.#activeCall = activeCall;
+    try {
+      const captureMethod: unknown = Reflect.get(this.#console, method);
+      if (typeof captureMethod === "function") {
+        Reflect.apply(captureMethod, this.#console, arguments_);
+      } else {
+        activeCall.chunks.push({
+          stream: streamForMethod(method),
+          text: fallbackConsoleText(method, arguments_)
+        });
+      }
+    } catch {
+      activeCall.chunks.push({
+        stream: "stderr",
+        text: `console.${method} output could not be formatted safely`
+      });
+    } finally {
+      this.#activeCall = previousCall;
+      this.#appendCall(activeCall);
+    }
+  }
+
+  public snapshot(): readonly CheckMessage[] {
+    return this.#messages.length === 0 ? Object.freeze([]) : Object.freeze([...this.#messages]);
+  }
+
+  #appendCall(call: ActiveConsoleCall): void {
+    const chunks = combineAdjacentChunks(call.chunks);
+    for (const chunk of chunks) {
+      this.#messages.push(
+        Object.freeze({
+          code: consoleMessageCode(call.method),
+          level: levelForConsoleCall(call.method, chunk.stream),
+          message: removeTerminalLineEnding(chunk.text)
+        })
+      );
+    }
+  }
+
+  #writer(stream: ConsoleStream): Writable {
+    return new Writable({
+      write: (
+        chunk: unknown,
+        _encoding: BufferEncoding,
+        callback: (error?: Error | null) => void
+      ) => {
+        const activeCall = this.#activeCall;
+        if (activeCall !== undefined) {
+          activeCall.chunks.push({ stream, text: String(chunk) });
+        }
+        callback();
+      }
+    });
+  }
+}
+
+function acquireConsoleRouter(): () => void {
+  if (activeRouterOwnerCount === 0) installConsoleRouter();
+  activeRouterOwnerCount += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    activeRouterOwnerCount -= 1;
+    if (activeRouterOwnerCount === 0) restoreConsoleRouter();
+  };
+}
+
+function installConsoleRouter(): void {
+  const installed: InstalledConsoleMethod[] = [];
+  try {
+    for (const method of consoleMethodNames(HOST_CONSOLE)) {
+      const original: unknown = Reflect.get(HOST_CONSOLE, method);
+      if (typeof original !== "function") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(HOST_CONSOLE, method);
+      const routed = function (this: Console, ...arguments_: unknown[]): unknown {
+        const capture = captureContext.getStore();
+        if (capture !== undefined) {
+          capture.invoke(method, arguments_);
+          return undefined;
+        }
+        return Reflect.apply(original, HOST_CONSOLE, arguments_);
+      };
+      Object.defineProperty(HOST_CONSOLE, method, {
+        configurable: true,
+        enumerable: descriptor?.enumerable ?? false,
+        value: routed,
+        writable: true
+      });
+      installed.push(Object.freeze({ descriptor, method }));
+    }
+    installedMethods = Object.freeze(installed);
+  } catch (error) {
+    restoreInstalledMethods(installed);
+    throw error;
+  }
+}
+
+function restoreConsoleRouter(): void {
+  restoreInstalledMethods(installedMethods);
+  installedMethods = Object.freeze([]);
+}
+
+function restoreInstalledMethods(methods: readonly InstalledConsoleMethod[]): void {
+  for (const { descriptor, method } of [...methods].reverse()) {
+    if (descriptor === undefined) {
+      Reflect.deleteProperty(HOST_CONSOLE, method);
+    } else {
+      Object.defineProperty(HOST_CONSOLE, method, descriptor);
+    }
+  }
+}
+
+function consoleMethodNames(value: Console): readonly string[] {
+  const names = new Set<string>();
+  let current: object | null = value;
+  while (current !== null && current !== Object.prototype) {
+    for (const key of Reflect.ownKeys(current)) {
+      if (typeof key === "string" && key !== "Console" && key !== "constructor") names.add(key);
+    }
+    current = Reflect.getPrototypeOf(current);
+  }
+  return Object.freeze(
+    [...names].filter((name) => typeof Reflect.get(value, name) === "function").sort(compareText)
+  );
+}
+
+function combineAdjacentChunks(
+  chunks: readonly Readonly<{ readonly stream: ConsoleStream; readonly text: string }>[]
+): readonly Readonly<{ readonly stream: ConsoleStream; readonly text: string }>[] {
+  const combined: Array<{ stream: ConsoleStream; text: string }> = [];
+  for (const chunk of chunks) {
+    const previous = combined.at(-1);
+    if (previous?.stream === chunk.stream) {
+      previous.text += chunk.text;
+    } else {
+      combined.push({ stream: chunk.stream, text: chunk.text });
+    }
+  }
+  return combined;
+}
+
+function fallbackConsoleText(method: string, arguments_: readonly unknown[]): string {
+  const formatted = formatWithOptions({ colors: false }, ...arguments_);
+  return formatted.length === 0 ? `console.${method}()` : formatted;
+}
+
+function consoleMessageCode(method: string): string {
+  const normalized = method
+    .replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replaceAll(/[^a-zA-Z0-9-]/g, "-")
+    .toLowerCase();
+  return `console-${normalized}`;
+}
+
+function levelForConsoleCall(method: string, stream: ConsoleStream): CheckMessageLevel {
+  if (method === "warn") return "warning";
+  if (method === "assert" || method === "error" || method === "trace") return "error";
+  return stream === "stderr" ? "error" : "info";
+}
+
+function streamForMethod(method: string): ConsoleStream {
+  return method === "assert" || method === "error" || method === "trace" || method === "warn"
+    ? "stderr"
+    : "stdout";
+}
+
+function removeTerminalLineEnding(text: string): string {
+  if (text.endsWith("\r\n") && text.length > 2) return text.slice(0, -2);
+  if (text.endsWith("\n") && text.length > 1) return text.slice(0, -1);
+  return text;
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}

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

@@ -1,25 +1,157 @@
-import type { CheckDependencies, CheckOutcome, DependencyReadResult } from "../../check/check.ts";
+import type {
+  CheckHandoffProvider,
+  CheckDependencies,
+  CheckOutcome,
+  DependencyHandoffReadResult,
+  DependencyObservation,
+  DependencyReadResult
+} from "../../check/check.ts";
+import {
+  getDefinedHandoffProviderIdentity,
+  type HandoffProviderIdentity
+} from "../../check/handoff-provider-identity.ts";
 import type { CoreCheckSession } from "../../check-settlement/session.ts";
+import { snapshotClosedRecord } from "../../data-boundary/closed-values.ts";
 import { diagnosticTags, type DiagnosticLogger } from "../diagnostic-logging/logger.ts";
+import type { ParsedCheckTerminalHandoff } from "./terminal-result.ts";
+
+type RuntimeDependencyHandoffReadResult = DependencyHandoffReadResult<string, object>;
 
 export function createCheckDependencies(
   input: Readonly<{
     readonly checkId: string;
+    readonly directDependsOnCheckIds: readonly string[];
     readonly diagnosticLogger: DiagnosticLogger | undefined;
-    readonly directDependencyIds: readonly string[];
+    readonly directRelationCheckIds: readonly string[];
+    readonly handoffsByCheckId: ReadonlyMap<string, ParsedCheckTerminalHandoff>;
     readonly session: CoreCheckSession;
   }>
 ): CheckDependencies {
-  return Object.freeze({
-    get: (dependencyId: string): DependencyReadResult => {
-      const result = readDependency(input.session, input.directDependencyIds, dependencyId);
+  function get<Id extends string, Handoff extends object>(
+    dependency: CheckHandoffProvider<Id, Handoff>
+  ): DependencyHandoffReadResult<Id, Handoff>;
+  function get(dependency: string): DependencyReadResult;
+  function get(dependency: unknown): DependencyReadResult | RuntimeDependencyHandoffReadResult;
+  function get(dependency: unknown): DependencyReadResult | RuntimeDependencyHandoffReadResult {
+    if (dependency === null || typeof dependency !== "object") {
+      const result = readDirectRelation(input.session, input.directRelationCheckIds, dependency);
       input.diagnosticLogger?.observe({
         event: "dependency.read",
         tags: diagnosticTags(`CHECK:${input.checkId}`, "EXECUTION", "DEPENDENCY-READ"),
-        details: dependencyReadDetails(dependencyId, result)
+        details: dependencyReadDetails(dependency, result)
       });
       return result;
     }
+    const result = readDirectDependencyHandoff(input, dependency);
+    input.diagnosticLogger?.observe({
+      event: "dependency.read",
+      tags: diagnosticTags(`CHECK:${input.checkId}`, "EXECUTION", "DEPENDENCY-READ"),
+      details: handoffDependencyReadDetails(dependency, result)
+    });
+    return result;
+  }
+  return Object.freeze({
+    get,
+    list: (): readonly DependencyObservation[] => {
+      const observations = listDirectRelationObservations(
+        input.session,
+        input.directRelationCheckIds
+      );
+      input.diagnosticLogger?.observe({
+        event: "dependency.list",
+        tags: diagnosticTags(`CHECK:${input.checkId}`, "EXECUTION", "DEPENDENCY-LIST"),
+        details: directRelationListDetails(observations)
+      });
+      return observations;
+    }
+  });
+}
+
+function readDirectDependencyHandoff(
+  input: Readonly<{
+    readonly directDependsOnCheckIds: readonly string[];
+    readonly handoffsByCheckId: ReadonlyMap<string, ParsedCheckTerminalHandoff>;
+    readonly session: CoreCheckSession;
+  }>,
+  provider: unknown
+): RuntimeDependencyHandoffReadResult {
+  const providerIdentity = handoffProviderIdentity(provider);
+  if (
+    providerIdentity === undefined ||
+    !input.directDependsOnCheckIds.includes(providerIdentity.checkId)
+  ) {
+    return handoffDependencyNotDeclared(providerIdentity?.checkId ?? handoffCheckId(provider));
+  }
+  const settledHandoff = input.handoffsByCheckId.get(providerIdentity.checkId);
+  const outcome = input.session.readSettledCheckOutcome(providerIdentity.checkId);
+  if (
+    settledHandoff === undefined ||
+    settledHandoff.identity !== providerIdentity.identity ||
+    outcome.status !== "passed"
+  ) {
+    return handoffUnavailable(providerIdentity.checkId);
+  }
+  return Object.freeze({
+    ok: true,
+    checkId: providerIdentity.checkId,
+    status: "passed",
+    data: outcome.data,
+    handoff: settledHandoff.value
+  });
+}
+
+function handoffProviderIdentity(
+  provider: unknown
+): Readonly<{ readonly checkId: string; readonly identity: HandoffProviderIdentity }> | undefined {
+  const identity = getDefinedHandoffProviderIdentity(provider);
+  const record = snapshotClosedRecord(provider);
+  if (
+    identity === undefined ||
+    record === undefined ||
+    typeof record.checkId !== "string" ||
+    record.handoff !== true
+  ) {
+    return undefined;
+  }
+  return Object.freeze({ checkId: record.checkId, identity });
+}
+
+function handoffCheckId(provider: unknown): string {
+  const record = snapshotClosedRecord(provider);
+  return record !== undefined && typeof record.checkId === "string" ? record.checkId : "";
+}
+
+function handoffDependencyNotDeclared(checkId: string): RuntimeDependencyHandoffReadResult {
+  return Object.freeze({
+    ok: false,
+    error: Object.freeze({ code: "dependency-not-declared", checkId })
+  });
+}
+
+function handoffUnavailable(checkId: string): RuntimeDependencyHandoffReadResult {
+  return Object.freeze({
+    ok: false,
+    error: Object.freeze({ code: "upstream-handoff-unavailable", checkId })
+  });
+}
+
+function listDirectRelationObservations(
+  session: CoreCheckSession,
+  directRelationCheckIds: readonly string[]
+): readonly DependencyObservation[] {
+  return Object.freeze(
+    directRelationCheckIds.map((checkId) =>
+      Object.freeze({ checkId, outcome: session.readSettledCheckOutcome(checkId) })
+    )
+  );
+}
+
+function directRelationListDetails(
+  observations: readonly DependencyObservation[]
+): Readonly<Record<string, unknown>> {
+  return Object.freeze({
+    dependencyIds: Object.freeze(observations.map(({ checkId }) => checkId)),
+    count: observations.length
   });
 }
 
@@ -38,12 +170,31 @@ function dependencyReadDetails(
   });
 }
 
-function readDependency(
+function handoffDependencyReadDetails(
+  requestedProvider: unknown,
+  result: RuntimeDependencyHandoffReadResult
+): Readonly<Record<string, unknown>> {
+  if (!result.ok) {
+    return Object.freeze({
+      error: result.error,
+      ok: false,
+      requestedCheckId: handoffCheckId(requestedProvider)
+    });
+  }
+  return Object.freeze({
+    hasData: true,
+    ok: true,
+    producer: result.checkId,
+    status: result.status
+  });
+}
+
+function readDirectRelation(
   session: CoreCheckSession,
-  directDependencyIds: readonly string[],
-  checkId: string
+  directRelationCheckIds: readonly string[],
+  checkId: unknown
 ): DependencyReadResult {
-  if (typeof checkId !== "string" || !directDependencyIds.includes(checkId)) {
+  if (typeof checkId !== "string" || !directRelationCheckIds.includes(checkId)) {
     return dependencyNotDeclared(checkId);
   }
   return dependencyReadResult(checkId, session.readSettledCheckOutcome(checkId));

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

@@ -1,16 +1,19 @@
 import type { CheckMessage } from "../../check/check.ts";
 import type { CoreSnapshot } from "../../check-settlement/facts.ts";
-import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
+import type {
+  NormalizedCheck,
+  SchedulerMeasurementContext
+} from "../../project-definition/project-definition.ts";
 import type { SettledTask } from "../task-scheduler/scheduler.ts";
 import type { CheckDuration, CheckRunMessage } from "../result.ts";
 import {
   CheckExecutionInvariantFailure,
   recordSettledCheck,
   type CheckIdentity,
+  type CheckExecutionState,
   type SettledCheckFacts
 } from "./execution-settlement.ts";
-import type { PreparedCheck } from "./preflight.ts";
-import type { CheckExecutionState, ResolvedCheckExecution } from "./resolved-checks.ts";
+import type { ResolvedCheckExecution } from "./resolved-execution-result.ts";
 
 const EMPTY_MESSAGES: readonly CheckMessage[] = Object.freeze([]);
 
@@ -18,49 +21,81 @@ const EMPTY_MESSAGES: readonly CheckMessage[] = Object.freeze([]);
 export function closeResolvedChecks(
   input: Readonly<{
     readonly allChecks: readonly NormalizedCheck[];
+    readonly effectiveCheckIds: readonly string[];
     readonly graphRun: Awaited<
-      ReturnType<typeof import("../task-scheduler/scheduler.ts").runTaskGraph<void>>
+      ReturnType<typeof import("../task-scheduler/scheduler.ts").runTaskGraph<boolean>>
     >;
-    readonly readyChecks: readonly PreparedCheck[];
     readonly state: CheckExecutionState;
   }>
 ): ResolvedCheckExecution {
   try {
     assertNoTaskEngineFailures(input.graphRun.settlements);
+    if (input.graphRun.admissionPolicyFault !== undefined) {
+      const terminalSchedulerMeasurement = input.graphRun.terminalMeasurement;
+      return closeAdmissionPolicyFailed({
+        normalizedChecks: input.allChecks,
+        state: input.state,
+        ...(terminalSchedulerMeasurement === undefined ? {} : { terminalSchedulerMeasurement })
+      });
+    }
     if (input.graphRun.cancelled) {
+      const terminalSchedulerMeasurement = input.graphRun.terminalMeasurement;
       return closeCancelledExecution({
         normalizedChecks: input.allChecks,
-        preparedChecks: input.readyChecks,
-        state: input.state
+        state: input.state,
+        ...(terminalSchedulerMeasurement === undefined ? {} : { terminalSchedulerMeasurement })
       });
     }
-    assertEveryCheckClosed(input.readyChecks, input.graphRun.settlements);
-    return resolvedExecution("completed", input.state.session.freeze(), input.state);
+    assertEveryCheckClosed(input.allChecks, input.graphRun.settlements);
+    return completedResolvedExecution(
+      input.effectiveCheckIds,
+      input.state.session.freeze(),
+      input.state,
+      input.graphRun.terminalMeasurement
+    );
   } catch (error) {
     throw trustedFailure(error);
   }
 }
 
+export function closeAdmissionPolicyFailed(
+  input: Readonly<{
+    readonly normalizedChecks: readonly NormalizedCheck[];
+    readonly state: CheckExecutionState;
+    readonly terminalSchedulerMeasurement?: SchedulerMeasurementContext;
+  }>
+): ResolvedCheckExecution {
+  input.state.session.closeUnresolvedAsCancelled();
+  const snapshot = input.state.session.freeze();
+  settleUnstartedCancelledChecks({ ...input, snapshot });
+  return resolvedExecution(
+    "admission-policy-failed",
+    snapshot,
+    input.state,
+    input.terminalSchedulerMeasurement
+  );
+}
+
 export function closeCancelledExecution(
   input: Readonly<{
     readonly normalizedChecks: readonly NormalizedCheck[];
-    readonly preparedChecks: readonly PreparedCheck[];
     readonly state: CheckExecutionState;
+    readonly terminalSchedulerMeasurement?: SchedulerMeasurementContext;
   }>
 ): ResolvedCheckExecution {
   input.state.session.closeUnresolvedAsCancelled();
   const snapshot = input.state.session.freeze();
   settleUnstartedCancelledChecks({ ...input, snapshot });
-  return resolvedExecution("cancelled", snapshot, input.state);
+  return resolvedExecution("cancelled", snapshot, input.state, input.terminalSchedulerMeasurement);
 }
 
 export function checkIdentity(
-  check: Pick<NormalizedCheck, "definition" | "visibility">
+  check: Pick<NormalizedCheck, "definition" | "omitQuietPassedRow">
 ): CheckIdentity {
   return Object.freeze({
     checkId: check.definition.checkId,
     displayName: check.definition.displayName,
-    visibility: check.visibility
+    omitQuietPassedRow: check.omitQuietPassedRow
   });
 }
 
@@ -73,21 +108,37 @@ export function trustedFailure(error: unknown): CheckExecutionInvariantFailure {
 }
 
 function resolvedExecution(
-  kind: ResolvedCheckExecution["kind"],
+  kind: Exclude<ResolvedCheckExecution["kind"], "completed">,
   snapshot: CoreSnapshot,
-  state: CheckExecutionState
+  state: CheckExecutionState,
+  terminalSchedulerMeasurement: SchedulerMeasurementContext | undefined
 ): ResolvedCheckExecution {
   return Object.freeze({
     kind,
     ...checkRunSummaries(snapshot, state.settledFactsByCheckId),
-    snapshot
+    snapshot,
+    ...(terminalSchedulerMeasurement === undefined ? {} : { terminalSchedulerMeasurement })
+  });
+}
+
+function completedResolvedExecution(
+  effectiveCheckIds: readonly string[],
+  snapshot: CoreSnapshot,
+  state: CheckExecutionState,
+  terminalSchedulerMeasurement: SchedulerMeasurementContext | undefined
+): Extract<ResolvedCheckExecution, { readonly kind: "completed" }> {
+  return Object.freeze({
+    kind: "completed",
+    ...checkRunSummaries(snapshot, state.settledFactsByCheckId),
+    effectiveCheckIds,
+    snapshot,
+    ...(terminalSchedulerMeasurement === undefined ? {} : { terminalSchedulerMeasurement })
   });
 }
 
 function settleUnstartedCancelledChecks(
   input: Readonly<{
     readonly normalizedChecks: readonly NormalizedCheck[];
-    readonly preparedChecks: readonly PreparedCheck[];
     readonly snapshot: CoreSnapshot;
     readonly state: CheckExecutionState;
   }>
@@ -95,9 +146,6 @@ function settleUnstartedCancelledChecks(
   const normalizedByCheckId = new Map(
     input.normalizedChecks.map((check) => [check.definition.checkId, check])
   );
-  const preparedByCheckId = new Map(
-    input.preparedChecks.map((check) => [check.definition.checkId, check])
-  );
   for (const check of input.snapshot.checks) {
     if (input.state.settledFactsByCheckId.has(check.checkId)) continue;
     const normalized = normalizedByCheckId.get(check.checkId);
@@ -109,7 +157,7 @@ function settleUnstartedCancelledChecks(
     recordSettledCheck({
       check: checkIdentity(normalized),
       durationMs: null,
-      messages: preparedByCheckId.get(check.checkId)?.preflightMessages ?? EMPTY_MESSAGES,
+      messages: EMPTY_MESSAGES,
       outcome: check.outcome,
       phase: "execution",
       state: input.state
@@ -135,7 +183,10 @@ function checkRunSummaries(
       throw new CheckExecutionInvariantFailure("Check settled facts are missing a Check");
     }
     checkDurations.push(
-      Object.freeze({ checkId: check.checkId, durationMs: settledFacts.durationMs })
+      Object.freeze({
+        checkId: check.checkId,
+        durationMs: settledFacts.durationMs
+      })
     );
     messages.push(
       ...settledFacts.messages.map((message) =>
@@ -149,22 +200,47 @@ function checkRunSummaries(
   });
 }
 
-function assertNoTaskEngineFailures(settlements: readonly SettledTask<void>[]): void {
+/** Closes one Scheduler-blocked Check before a terminal observer may start. */
+export function settleBlockedDependent(
+  input: Readonly<{
+    readonly check: NormalizedCheck;
+    readonly dependencyIds: readonly string[];
+    readonly state: CheckExecutionState;
+  }>
+): void {
+  const scope = input.state.session.openCheckScope(input.check.definition.checkId);
+  const outcome = scope.settleProduct(
+    Object.freeze({
+      status: "unavailable" as const,
+      reason: Object.freeze({
+        code: "dependency-not-passed",
+        checkIds: Object.freeze([...input.dependencyIds])
+      })
+    })
+  );
+  recordSettledCheck({
+    check: checkIdentity(input.check),
+    durationMs: null,
+    messages: EMPTY_MESSAGES,
+    outcome,
+    phase: "dependency",
+    state: input.state
+  });
+}
+
+function assertNoTaskEngineFailures(settlements: readonly SettledTask<boolean>[]): void {
   for (const settled of settlements) {
     if (settled.settlement.kind === "failed") {
       throw new CheckExecutionInvariantFailure(
         "Task engine received an unexpected execution failure"
       );
     }
-    if (settled.settlement.kind === "blocked") {
-      throw new CheckExecutionInvariantFailure("Task engine blocked a Product Check");
-    }
   }
 }
 
 function assertEveryCheckClosed(
   checks: readonly NormalizedCheck[],
-  settlements: readonly SettledTask<void>[]
+  settlements: readonly SettledTask<boolean>[]
 ): void {
   if (settlements.some((settled) => settled.settlement.kind === "cancelled-before-start")) {
     throw new CheckExecutionInvariantFailure("Non-cancelled Task graph left a Check unstarted");