@zxyycom/vibe-check 0.0.1 → 0.0.2

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

@@ -0,0 +1,116 @@
+import { randomUUID } from "node:crypto";
+
+import {
+  createDeclarativeFingerprint,
+  type DefinitionWarning,
+  type NormalizedProjectDefinition,
+  type ProjectDefinition,
+  type ResolvedProjectOutputs
+} from "../../project-definition/project-definition.ts";
+import type { RunControls } from "../controls/contract.ts";
+import {
+  createDiagnosticLogger,
+  createDiagnosticLoggingRouter
+} from "../diagnostic-logging/logger.ts";
+import type { Invocation, RunInvocationDependencies } from "./run.ts";
+import { createOutputStatuses } from "../outputs/status.ts";
+import { effectiveOutputs } from "../outputs/configuration.ts";
+import { resolveInvocationPaths } from "./paths.ts";
+import { createProgressRendering } from "../progress-rendering/presentation.ts";
+
+const SYSTEM_MONOTONIC_CLOCK: Invocation["clock"] = Object.freeze({
+  now: () => performance.now()
+});
+
+export interface InvocationCreationInput {
+  readonly controls: RunControls;
+  readonly definition: ProjectDefinition;
+  readonly definitionWarnings: readonly DefinitionWarning[];
+  readonly dependencies: RunInvocationDependencies;
+  readonly normalized: NormalizedProjectDefinition;
+}
+
+/** Creates immutable invocation-owned output state before any planning or execution work. */
+export function createInvocation(input: InvocationCreationInput): Invocation {
+  const outputConfiguration = effectiveOutputs(input.definition, input.controls);
+  const clock = input.dependencies.clock ?? SYSTEM_MONOTONIC_CLOCK;
+  const diagnosticLoggingEnabled = outputConfiguration.diagnosticLogging.enabled;
+  const startedAtUtc = captureOutputCreationTimestamp(outputConfiguration, input.dependencies);
+  const identity = createInvocationIdentity();
+  const paths = resolveInvocationPaths({
+    checkArtifactBaseDirectory: input.controls.checkArtifactBaseDirectory,
+    checkIds: input.normalized.checks.map((check) => check.definition.checkId),
+    diagnosticLogFileNaming: input.controls.diagnosticLogFileNaming ?? "unique",
+    diagnosticLogSuffix: diagnosticLoggingEnabled
+      ? diagnosticLogSuffix(requireStartedAtUtc(startedAtUtc), identity.uuid)
+      : undefined,
+    outputConfiguration,
+    progressLogFile: input.controls.progressLogFile,
+    projectRoot: input.controls.projectRoot ?? process.cwd()
+  });
+  const outputs = createOutputStatuses(
+    outputConfiguration,
+    paths.diagnosticLoggingReadbackFiles,
+    input.normalized.scheduler.measurementHooks.length > 0
+  );
+  const diagnosticLogging = createDiagnosticLoggingRouter({
+    clock,
+    coreFile: paths.diagnosticLoggingFiles.core,
+    factory: input.dependencies.diagnosticLoggerFactory ?? createDiagnosticLogger,
+    invocationId: identity.id,
+    schedulerFile: paths.diagnosticLoggingFiles.scheduler
+  });
+
+  return Object.freeze({
+    admissionStrategyProviderFactory: input.dependencies.admissionStrategyProviderFactory,
+    clock,
+    controls: input.controls,
+    declarativeFingerprint: createDeclarativeFingerprint(input.normalized.declarative),
+    definition: input.definition,
+    definitionWarnings: Object.freeze([...input.definitionWarnings]),
+    diagnosticLogging,
+    diagnosticLoggingEnabled,
+    outputConfiguration,
+    outputs,
+    invocationId: identity.id,
+    paths,
+    normalized: input.normalized,
+    progressRendering: createProgressRendering(outputConfiguration.progressRendering, outputs, {
+      clock,
+      refreshScheduler: input.dependencies.progressRefreshScheduler,
+      writerFactory: input.dependencies.progressWriterFactory,
+      file: paths.progressLogFile
+    }),
+    startedAtUtc
+  });
+}
+
+function captureOutputCreationTimestamp(
+  outputConfiguration: ResolvedProjectOutputs,
+  dependencies: RunInvocationDependencies
+): string | null {
+  if (
+    !outputConfiguration.diagnosticLogging.enabled &&
+    !outputConfiguration.machinePublication.enabled
+  )
+    return null;
+  return (dependencies.wallClock?.now() ?? new Date()).toISOString();
+}
+
+function createInvocationIdentity(): Readonly<{
+  readonly id: string;
+  readonly uuid: string;
+}> {
+  const uuid = randomUUID();
+  return Object.freeze({ id: `invocation/v1:${uuid}`, uuid });
+}
+
+function diagnosticLogSuffix(startedAtUtc: string, invocationUuid: string): string {
+  const compactUtc = startedAtUtc.replaceAll("-", "").replaceAll(":", "");
+  return `${compactUtc}-${invocationUuid}`;
+}
+
+function requireStartedAtUtc(startedAtUtc: string | null): string {
+  if (startedAtUtc === null) throw new Error("Enabled output requires an invocation timestamp");
+  return startedAtUtc;
+}

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.ts → invocation/run.ts}

@@ -1,60 +1,73 @@
-import type { CheckProjectContext } from "../check/check.ts";
-import type { CoreSnapshot } from "../check-settlement/facts.ts";
+import type { CheckProjectContext } from "../../check/check.ts";
 import {
   normalizeProjectDefinition,
   type DefinitionWarning,
   type NormalizedProjectDefinition,
-  type ProjectDefinition
-} from "../project-definition/project-definition.ts";
-import type { CheckAggregation, RunControls } from "./controls/contract.ts";
-import { prepareTaskGraph } from "./task-scheduler/graph.ts";
-import { aggregateCheckOutcomes, validateCheckAggregationSelection } from "./aggregation.ts";
+  type ProjectDefinition,
+  type ResolvedProjectOutputs
+} from "../../project-definition/project-definition.ts";
+import type { CheckAggregation, RunControls } from "../controls/contract.ts";
 import {
-  executeResolvedChecks,
-  type CheckExecutionClock,
-  type ResolvedCheckExecution
-} from "./check-execution/resolved-checks.ts";
-import { planStaticCheckGraph } from "./check-execution/plan.ts";
+  createAdmissionStrategyProvider,
+  type AdmissionStrategyProviderFactory
+} from "../admission-strategy-provider/provider.ts";
+import { AdmissionStrategyPreparationFailure } from "../admission-strategy-provider/custom-strategy-preparation.ts";
+import type { PreparedAdmissionStrategy } from "../admission-strategy-provider/prepared-admission-strategy.ts";
+import { prepareTaskGraph } from "../task-scheduler/graph.ts";
+import { validateCheckAggregationSelection } from "../aggregation.ts";
+import { type CheckExecutionClock } from "../check-execution/resolved-checks.ts";
+import type { ResolvedCheckExecution } from "../check-execution/resolved-execution-result.ts";
+import { planStaticCheckGraph } from "../check-execution/plan.ts";
 import {
   type ProgressRefreshScheduler,
   type ProgressRendering,
   type ProgressWriterFactory
-} from "./progress-rendering/presentation.ts";
-import { completeInvocation, finalizeInvocation, type CoreExecution } from "./completion.ts";
-import { createProjectContext } from "./project-context.ts";
+} from "../progress-rendering/presentation.ts";
+import { finalizeInvocation } from "../completion/completion.ts";
+import { createProjectContext } from "../project-context.ts";
+import type { ResolvedInvocationPaths } from "./paths.ts";
 import {
-  executionCancellation,
   isCancelled,
   planning,
   preExecutionCancellation,
   type NonConfigurationRunResult,
   type RunDiagnostic,
   type RunResult
-} from "./result.ts";
+} from "../result.ts";
 import {
   diagnosticTags,
-  type DiagnosticLogger,
-  type DiagnosticLoggerFactory
-} from "./diagnostic-logging/logger.ts";
-import { createInvocation } from "./invocation-creation.ts";
-import type { OutputStatuses } from "./output-status.ts";
+  summarizeDiagnosticValue,
+  type DiagnosticLoggerFactory,
+  type DiagnosticLoggingRouter
+} from "../diagnostic-logging/logger.ts";
+import { createInvocation } from "./creation.ts";
+import type { OutputStatuses } from "../outputs/status.ts";
+import { executeScheduler, type SchedulerExecution } from "./scheduler.ts";
+import { mapResolvedExecutionToRunCandidate } from "./candidate.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 diagnosticLogger: DiagnosticLogger;
-  readonly outputConfiguration: ProjectDefinition["outputs"];
+  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;
-  readonly projectRoot: string;
   /** 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;
@@ -62,6 +75,7 @@ export interface RunInvocationDependencies {
   /** Test seam for the invocation's machine-readable wall-clock timestamp. */
   readonly wallClock?: Readonly<{ now(): Date }>;
 }
+
 export async function executeValidatedRun(
   definition: ProjectDefinition,
   controls: RunControls,
@@ -107,14 +121,13 @@ function observeInvocationStarted(
   invocation: Invocation,
   aggregation: CheckAggregation | undefined
 ): void {
-  invocation.diagnosticLogger.observe({
+  invocation.diagnosticLogging.core.observe({
     event: "run.started",
     tags: diagnosticTags("RUN", "STARTED"),
     details: {
       aggregation: aggregation ?? null,
       checkCount: invocation.normalized.checks.length,
-      flags: invocation.controls.flags ?? [],
-      invocationId: invocation.invocationId,
+      flags: summarizeDiagnosticValue(invocation.controls.flags ?? []),
       outputs: invocation.outputConfiguration,
       scheduler: invocation.normalized.declarative.scheduler
     }
@@ -124,10 +137,13 @@ function observeInvocationStarted(
 function validateTaskGraph(invocation: Invocation): boolean {
   try {
     prepareTaskGraph(
-      planStaticCheckGraph(invocation.normalized.checks),
+      planStaticCheckGraph(
+        invocation.normalized.checks,
+        invocation.normalized.declarative.scheduler.resourceCapacities
+      ),
       invocation.normalized.declarative.scheduler.maxParallel
     );
-    invocation.diagnosticLogger.observe({
+    invocation.diagnosticLogging.core.observe({
       event: "run.planning.succeeded",
       tags: diagnosticTags("RUN", "PLANNING", "SUCCEEDED"),
       details: {
@@ -137,7 +153,7 @@ function validateTaskGraph(invocation: Invocation): boolean {
     });
     return true;
   } catch {
-    invocation.diagnosticLogger.observe({
+    invocation.diagnosticLogging.core.observe({
       event: "run.planning.failed",
       tags: diagnosticTags("RUN", "PLANNING", "FAILED"),
       details: {
@@ -156,7 +172,7 @@ async function executePlannedInvocation(
   return executePreparedInvocation(
     invocation,
     aggregation,
-    createProjectContext({ controls: invocation.controls, root: invocation.projectRoot })
+    createProjectContext({ controls: invocation.controls, paths: invocation.paths })
   );
 }
 async function executePreparedInvocation(
@@ -165,51 +181,88 @@ async function executePreparedInvocation(
   project: CheckProjectContext
 ): Promise<NonConfigurationRunResult> {
   if (isCancelled(invocation.controls)) return cancelledBeforeExecution(invocation, "planning");
+  let preparedStrategy: PreparedAdmissionStrategy;
+  try {
+    preparedStrategy = await prepareAdmissionStrategy(invocation);
+  } catch (error) {
+    if (error instanceof AdmissionStrategyPreparationFailure) {
+      return executionResult(invocation, "admission-strategy-preparation-failed");
+    }
+    throw error;
+  }
+  if (preparedStrategy.completion.kind === "measurement-hook") {
+    invocation.outputs.enableMeasurementHooks();
+  }
   invocation.progressRendering.prepared(invocation.normalized.checks.length);
   const executionStartedAt = invocation.clock.now();
-  const executed = await executeChecks(invocation, project, invocation.clock);
+  const executed = await executeScheduler({ invocation, preparedStrategy, project });
   if (isExecutionRunResult(executed)) return executed;
-  invocation.progressRendering.final({
-    counts: outcomeCounts(executed.snapshot),
-    elapsedMs: elapsedSince(executionStartedAt, invocation.clock),
-    execution: executed.kind
-  });
-  if (executed.kind === "cancelled") {
-    invocation.diagnosticLogger.observe({
-      event: "run.execution.cancelled",
-      tags: diagnosticTags("RUN", "EXECUTION", "CANCELLED"),
-      details: { checkCount: executed.snapshot.checks.length }
-    });
-    return executionCancellation({
-      checkDurations: executed.checkDurations,
-      checkMessages: executed.checkMessages,
-      declarativeFingerprint: invocation.declarativeFingerprint,
-      definitionWarnings: invocation.definitionWarnings,
-      outputs: invocation.outputs.value(),
-      snapshot: executed.snapshot
-    });
-  }
-  const aggregate =
-    aggregation === undefined ? null : aggregateCheckOutcomes(executed.snapshot, aggregation);
-  invocation.diagnosticLogger.observe({
-    event: "run.aggregation.completed",
-    tags: diagnosticTags("RUN", "AGGREGATION", "COMPLETED"),
-    details: { aggregate, selection: aggregation ?? null }
+  await completeAdmissionStrategyAfterTerminalMeasurement(
+    preparedStrategy,
+    executed,
+    invocation.outputs
+  );
+  return mapResolvedExecutionToRunCandidate({
+    aggregation,
+    executed,
+    executionStartedAt,
+    invocation
   });
-  const core: CoreExecution = Object.freeze({
-    aggregate,
-    checkDurations: executed.checkDurations,
-    checkMessages: executed.checkMessages,
-    snapshot: executed.snapshot
+}
+
+/** Composes one invocation-local strategy only after the static Task graph is valid. */
+async function prepareAdmissionStrategy(
+  invocation: Invocation
+): Promise<PreparedAdmissionStrategy> {
+  const graph = prepareTaskGraph(
+    planStaticCheckGraph(
+      invocation.normalized.checks,
+      invocation.normalized.declarative.scheduler.resourceCapacities
+    ),
+    invocation.normalized.declarative.scheduler.maxParallel
+  );
+  const admissionStrategyProviderFactory =
+    invocation.admissionStrategyProviderFactory ?? createAdmissionStrategyProvider;
+  const provider = admissionStrategyProviderFactory({
+    admissionPolicy: invocation.normalized.scheduler.admissionPolicy,
+    graph: graph.schedulerGraphSnapshot
   });
-  return completeInvocation(invocation, core);
+  return provider.prepare();
+}
+
+/** The prepared provider closes only after Scheduler terminal measurement and Hooks have settled. */
+async function completeAdmissionStrategyAfterTerminalMeasurement(
+  preparedStrategy: PreparedAdmissionStrategy,
+  executed: ResolvedCheckExecution,
+  outputs: OutputStatuses
+): Promise<void> {
+  const terminalMeasurement = executed.terminalSchedulerMeasurement;
+  if (terminalMeasurement === undefined) return;
+  switch (preparedStrategy.completion.kind) {
+    case "none":
+      return;
+    case "internal":
+      try {
+        await preparedStrategy.completion.complete(Object.freeze({ terminalMeasurement }));
+      } catch {
+        // Private learned lifecycle cannot revise sealed execution or public output facts.
+      }
+      return;
+    case "measurement-hook":
+      try {
+        await preparedStrategy.completion.complete(terminalMeasurement);
+        outputs.succeeded("measurementHooks");
+      } catch {
+        outputs.failed("measurementHooks");
+      }
+  }
 }
 
 function cancelledBeforeExecution(
   invocation: Invocation,
   phase: "pre-work" | "planning"
 ): NonConfigurationRunResult {
-  invocation.diagnosticLogger.observe({
+  invocation.diagnosticLogging.core.observe({
     event: "run.cancelled",
     tags: diagnosticTags("RUN", "CANCELLED"),
     details: { phase }
@@ -222,57 +275,6 @@ function cancelledBeforeExecution(
   );
 }
 
-async function executeChecks(
-  invocation: Invocation,
-  project: CheckProjectContext,
-  clock: CheckExecutionClock
-): Promise<ResolvedCheckExecution | NonConfigurationRunResult> {
-  try {
-    return await executeResolvedChecks({
-      checks: invocation.normalized.checks,
-      clock,
-      diagnosticLogger: invocation.diagnosticLogger,
-      maxParallel: invocation.normalized.declarative.scheduler.maxParallel,
-      lifecycle: invocation.progressRendering.lifecycle,
-      project,
-      signal: invocation.controls.signal
-    });
-  } catch {
-    return executionResult(invocation, "task-engine-failed");
-  }
-}
-function outcomeCounts(snapshot: CoreSnapshot): Readonly<{
-  readonly failed: number;
-  readonly notApplicable: number;
-  readonly passed: number;
-  readonly unavailable: number;
-}> {
-  let failed = 0,
-    notApplicable = 0,
-    passed = 0,
-    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 });
-}
-function elapsedSince(startedAt: number, clock: CheckExecutionClock): number {
-  const elapsed = clock.now() - startedAt;
-  return Number.isFinite(elapsed) && elapsed >= 0 ? elapsed : 0;
-}
 function planningResult(
   invocation: Invocation,
   code: Extract<RunDiagnostic["code"], "task-graph-invalid">
@@ -286,7 +288,10 @@ function planningResult(
 }
 function executionResult(
   invocation: Invocation,
-  code: Extract<RunDiagnostic["code"], "publication-model-failed" | "task-engine-failed">
+  code: Extract<
+    RunDiagnostic["code"],
+    "admission-strategy-preparation-failed" | "task-engine-failed"
+  >
 ): NonConfigurationRunResult {
   return Object.freeze({
     kind: "execution",
@@ -297,7 +302,7 @@ function executionResult(
   });
 }
 function isExecutionRunResult(
-  value: ResolvedCheckExecution | NonConfigurationRunResult
-): value is NonConfigurationRunResult {
+  value: SchedulerExecution
+): value is Extract<NonConfigurationRunResult, { readonly kind: "execution" }> {
   return "declarativeFingerprint" in value;
 }