@zxyycom/vibe-check 0.0.1 → 0.0.3

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

@@ -1,90 +1,64 @@
+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";
-import {
-  diagnosticTags,
-  summarizeDiagnosticValue,
-  type DiagnosticLogger
-} from "../diagnostic-logging/logger.ts";
+  NormalizedCheck,
+  SchedulerTerminalEffect
+} from "../../project-definition/project-definition.ts";
+import type { ResourceUnitMapping } from "../../project-definition/resource-unit-mapping.ts";
+import { createCoreCheckSession } from "../../check-settlement/session.ts";
+import type { DiagnosticLogger } from "../diagnostic-logging/logger.ts";
+import type { AdmissionSelectionPolicy } from "../task-scheduler/admission-selection-policy.ts";
 import { prepareTaskGraph } from "../task-scheduler/graph.ts";
-import { runTaskGraph } from "../task-scheduler/scheduler.ts";
-import { executeCheckCallback } from "./callback.ts";
-import { createCheckDependencies } from "./dependencies.ts";
+import type { SchedulerPerformanceDiagnosticsInput } from "../task-scheduler/measurement/diagnostics.ts";
+import type { ResolvedInvocationPaths } from "../invocation/paths.ts";
+import { runWithCheckConsoleRouter } from "./console-capture.ts";
 import {
-  CheckExecutionInvariantFailure,
   recordSettledCheck,
-  settleCallback,
-  type CheckExecutionSettlementState,
-  type CheckIdentity,
+  type CheckExecutionState,
   type SettledCheckFacts
 } from "./execution-settlement.ts";
-import {
-  checkIdentity,
-  closeCancelledExecution,
-  closeResolvedChecks,
-  trustedFailure
-} from "./execution-finalization.ts";
+import { checkIdentity, closeResolvedChecks } from "./execution-finalization.ts";
+import type { CheckExecutionLifecycle, InvocationLifecycle } from "./lifecycle.ts";
 import { planStaticCheckGraph } from "./plan.ts";
 import {
-  prepareChecks,
-  type CheckPreflightResolution,
-  type PreparedCheck,
-  type ReadyCheckPreflightResolution
-} from "./preflight.ts";
+  selectEffectiveCheckIds,
+  resolveFlagControlSettlements,
+  type FlagControlSettlement
+} from "./flag-controls.ts";
+import { runScheduledChecks } from "./scheduled-check-run.ts";
+import type { CheckExecutionClock } from "./admitted-check-execution.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([]);
 
 /** 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 clock: CheckExecutionClock;
+export type { CheckExecutionClock } from "./admitted-check-execution.ts";
+
+export 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;
-}
-
-type PreparedResolvedCheckExecution = Readonly<{
-  readonly blockedCheckIds: ReadonlySet<string>;
-  readonly readyChecks: readonly PreparedCheck[];
-  readonly readyPreflights: readonly ReadyCheckPreflightResolution[];
-  readonly state: CheckExecutionState;
+  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 schedulerTerminalEffects?: readonly SchedulerTerminalEffect[];
+  readonly onSchedulerTerminalEffectFailure?: () => void;
+  readonly onSchedulerTerminalEffectsSettled?: () => void;
+  readonly checkLifecycle?: CheckExecutionLifecycle;
+  readonly invocationLifecycle?: InvocationLifecycle;
+  /** Provider-owned bounded learned admission diagnostics, delivered by invocation. */
+  readonly onAdmittedCheck?: (check: NormalizedCheck) => void;
 }>;
 
 /**
@@ -92,87 +66,48 @@ 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
-    });
-  }
-  const readyPreflightByCheckId = new Map(
-    prepared.readyPreflights.map((preflight) => [preflight.check.definition.checkId, preflight])
-  );
-  const graph = planStaticCheckGraph(prepared.readyChecks, {
-    alreadySettledCheckIds: prepared.blockedCheckIds
-  });
-  let graphRun: Awaited<ReturnType<typeof runTaskGraph<void>>>;
-  try {
-    graphRun = await runTaskGraph({
-      graph,
-      maxParallel: input.maxParallel,
-      diagnosticLogger: input.diagnosticLogger,
-      signal: input.signal,
-      execute: (task, context) => {
-        const preflight = readyPreflightByCheckId.get(task.id);
-        if (preflight === undefined) {
-          throw new CheckExecutionInvariantFailure("Task graph has no prepared Check");
-        }
-        return executeCheck({
-          ...prepared.state,
-          preflight,
-          clock: input.clock ?? SYSTEM_MONOTONIC_CLOCK,
-          project: input.project,
-          signal: context.signal ?? INERT_SIGNAL
-        });
-      }
-    });
-  } catch (error) {
-    throw trustedFailure(error);
-  }
-
-  return closeResolvedChecks({
-    allChecks: input.checks,
-    graphRun,
-    readyChecks: 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 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
-  });
+async function executePreparedResolvedChecks(
+  input: ResolvedCheckExecutionInput,
+  effectiveCheckIds: readonly string[]
+): Promise<ResolvedCheckExecution> {
   const state = createExecutionState({
     checks: input.checks,
     diagnosticLogger: input.diagnosticLogger,
-    lifecycle: input.lifecycle
+    lifecycle: input.checkLifecycle
   });
-  const partition = settlePreflightResolutions(state, preflights);
-  return Object.freeze({ ...partition, state });
+  try {
+    const flagControlSettlements = resolveFlagControlSettlements({
+      checks: input.checks,
+      ...(input.diagnosticLogger === undefined ? {} : { diagnosticLogger: input.diagnosticLogger }),
+      effectiveCheckIds,
+      signal: input.signal
+    });
+    for (const settlement of flagControlSettlements) {
+      settleFlagControlOutcome(state, settlement);
+    }
+    input.invocationLifecycle?.selectionSettled();
+    const graphRun = await runScheduledChecks({
+      execution: input,
+      flagControlSettlements,
+      state
+    });
+
+    return closeResolvedChecks({
+      allChecks: input.checks,
+      effectiveCheckIds,
+      graphRun,
+      state
+    });
+  } finally {
+    state.handoffsByCheckId.clear();
+  }
 }
 
 function createExecutionState(
@@ -184,6 +119,7 @@ function createExecutionState(
 ): CheckExecutionState {
   return {
     diagnosticLogger: input.diagnosticLogger,
+    handoffsByCheckId: new Map(),
     settledFactsByCheckId: new Map<string, SettledCheckFacts>(),
     lifecycle: input.lifecycle,
     session: createCoreCheckSession(
@@ -192,94 +128,18 @@ function createExecutionState(
   };
 }
 
-function settlePreflightResolutions(
-  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)
-  });
-}
-
-function settleBlockedPreflight(
+function settleFlagControlOutcome(
   state: CheckExecutionState,
-  preflight: Extract<CheckPreflightResolution, { readonly kind: "blocked" }>
+  settlement: FlagControlSettlement
 ): void {
-  const scope = state.session.openCheckScope(preflight.check.definition.checkId);
-  const outcome = scope.settleProduct(preflight.outcome);
+  const scope = state.session.openCheckScope(settlement.check.definition.checkId);
+  const outcome = scope.settleProduct(settlement.outcome);
   recordSettledCheck({
-    check: checkIdentity(preflight.check),
+    check: checkIdentity(settlement.check),
     durationMs: null,
-    messages: preflight.check.preflightMessages,
+    messages: NO_CHECK_MESSAGES,
     outcome,
-    phase: "preflight",
+    phase: "control",
     state
   });
 }
-
-async function executeCheck(input: ExecuteCheckInput): Promise<void> {
-  const check = input.preflight.check;
-  const checkId = check.definition.checkId;
-  const scope = input.session.openCheckScope(checkId);
-  const identity = checkIdentity(check);
-  input.diagnosticLogger?.observe({
-    event: "check.started",
-    tags: diagnosticTags(`CHECK:${checkId}`, "EXECUTION", "STARTED"),
-    details: {
-      dependencies: check.dependsOn,
-      displayName: check.definition.displayName,
-      options: summarizeDiagnosticValue(check.options)
-    }
-  });
-  emitStarted(input.lifecycle, identity);
-  const startedAt = input.clock.now();
-  const callback = await executeCheckCallback({
-    check,
-    dependencies: createCheckDependencies({
-      checkId,
-      diagnosticLogger: input.diagnosticLogger,
-      directDependencyIds: check.dependsOn,
-      session: input.session
-    }),
-    diagnosticLogger: input.diagnosticLogger,
-    project: input.project,
-    scope,
-    signal: input.signal
-  });
-  const settled = settleCallback({
-    callback,
-    checkId,
-    diagnosticLogger: input.diagnosticLogger,
-    preflightMessages: check.preflightMessages,
-    scope
-  });
-  recordSettledCheck({
-    check: identity,
-    durationMs: durationSince(startedAt, input.clock),
-    messages: settled.messages,
-    outcome: settled.outcome,
-    phase: "execution",
-    state: input
-  });
-}
-
-function emitStarted(lifecycle: CheckExecutionLifecycle | undefined, check: CheckIdentity): void {
-  lifecycle?.started(Object.freeze({ checkId: check.checkId, displayName: check.displayName }));
-}
-
-function durationSince(startedAt: number, clock: CheckExecutionClock): number {
-  const elapsed = clock.now() - startedAt;
-  return Number.isFinite(elapsed) && elapsed >= 0 ? elapsed : 0;
-}

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);

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

@@ -0,0 +1,119 @@
+/** Maps normalized Checks into the Scheduler's opaque Task execute contract. */
+
+import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
+import { runTaskGraph, type RunTaskGraphOptions } from "../task-scheduler/scheduler.ts";
+import {
+  CheckExecutionInvariantFailure,
+  type CheckExecutionState
+} from "./execution-settlement.ts";
+import { settleBlockedDependent, trustedFailure } from "./execution-finalization.ts";
+import type { FlagControlSettlement } from "./flag-controls.ts";
+import { planStaticCheckGraph } from "./plan.ts";
+import {
+  executeAdmittedCheck,
+  type AdmittedCheckExecutionInput,
+  type CheckExecutionClock
+} from "./admitted-check-execution.ts";
+import type { ResolvedCheckExecutionInput } from "./resolved-checks.ts";
+
+const INERT_SIGNAL = new AbortController().signal;
+const DIRECT_EXECUTION_INVOCATION_ID = "invocation/v1:direct-check-execution";
+const SYSTEM_MONOTONIC_CLOCK: CheckExecutionClock = Object.freeze({
+  now: () => performance.now()
+});
+
+export async function runScheduledChecks(
+  input: Readonly<{
+    readonly execution: ResolvedCheckExecutionInput;
+    readonly flagControlSettlements: readonly FlagControlSettlement[];
+    readonly state: CheckExecutionState;
+  }>
+): Promise<Awaited<ReturnType<typeof runTaskGraph<boolean>>>> {
+  try {
+    return await runTaskGraph(schedulerOptionsFor(input));
+  } catch (error) {
+    throw trustedFailure(error);
+  }
+}
+
+function schedulerOptionsFor(
+  input: Readonly<{
+    readonly execution: ResolvedCheckExecutionInput;
+    readonly flagControlSettlements: readonly FlagControlSettlement[];
+    readonly state: CheckExecutionState;
+  }>
+): RunTaskGraphOptions<boolean> {
+  const execution = input.execution;
+  const checksByCheckId = new Map(
+    execution.checks.map((check) => [check.definition.checkId, check] as const)
+  );
+  const schedulerDiagnosticLogger =
+    execution.schedulerDiagnosticLogger ?? execution.diagnosticLogger;
+  return {
+    graph: planStaticCheckGraph(execution.checks, execution.resourceCapacities),
+    ...(execution.admissionPolicy === undefined
+      ? {}
+      : { admissionPolicy: execution.admissionPolicy }),
+    maxParallel: execution.maxParallel,
+    ...(schedulerDiagnosticLogger === undefined
+      ? {}
+      : { diagnosticLogger: schedulerDiagnosticLogger }),
+    ...(execution.schedulerPerformanceDiagnostics === undefined
+      ? {}
+      : { performanceDiagnostics: execution.schedulerPerformanceDiagnostics }),
+    ...(execution.schedulerTerminalEffects === undefined
+      ? {}
+      : { terminalEffects: execution.schedulerTerminalEffects }),
+    ...(execution.onSchedulerTerminalEffectFailure === undefined
+      ? {}
+      : { onTerminalEffectFailure: execution.onSchedulerTerminalEffectFailure }),
+    ...(execution.onSchedulerTerminalEffectsSettled === undefined
+      ? {}
+      : { onTerminalEffectsSettled: execution.onSchedulerTerminalEffectsSettled }),
+    preAdmissionTaskResults: Object.freeze(
+      input.flagControlSettlements.map((settlement) =>
+        Object.freeze({ taskId: settlement.check.definition.checkId, value: false })
+      )
+    ),
+    ...(execution.signal === undefined ? {} : { signal: execution.signal }),
+    isPrerequisiteSatisfied: (satisfied) => satisfied,
+    onTaskBlocked: (task, dependencyIds) => {
+      settleBlockedDependent({
+        check: requiredNormalizedCheck(checksByCheckId, task, "Blocked Task"),
+        dependencyIds,
+        state: input.state
+      });
+    },
+    execute: (task, context) =>
+      executeAdmittedCheck({
+        ...input.state,
+        ...admittedExecutionFacts(execution),
+        check: requiredNormalizedCheck(checksByCheckId, task, "Task graph"),
+        signal: context.signal ?? INERT_SIGNAL
+      })
+  };
+}
+
+function requiredNormalizedCheck(
+  checksByCheckId: ReadonlyMap<string, NormalizedCheck>,
+  task: Readonly<{ readonly id: string }>,
+  owner: "Blocked Task" | "Task graph"
+): NormalizedCheck {
+  const check = checksByCheckId.get(task.id);
+  if (check === undefined) {
+    throw new CheckExecutionInvariantFailure(`${owner} has no normalized Check`);
+  }
+  return check;
+}
+
+function admittedExecutionFacts(
+  execution: ResolvedCheckExecutionInput
+): Omit<AdmittedCheckExecutionInput, keyof CheckExecutionState | "check" | "signal"> {
+  return {
+    clock: execution.clock ?? SYSTEM_MONOTONIC_CLOCK,
+    onAdmittedCheck: execution.onAdmittedCheck,
+    invocationId: execution.invocationId ?? DIRECT_EXECUTION_INVOCATION_ID,
+    paths: execution.paths,
+    project: execution.project
+  };
+}