@zxyycom/vibe-check 0.0.2 → 0.0.3

package/src/project-run/progress-rendering/renderer.ts

@@ -1,4 +1,4 @@
-import type { CheckMessage, CheckOutcome, CheckVisibility } from "../../check/check.ts";
+import type { CheckMessage, CheckOutcome } from "../../check/check.ts";
 import type { CoreRecord } from "../../check-settlement/facts.ts";
 import type { ResolvedProgressRenderingOutput } from "../../project-definition/project-definition.ts";
 import { resolveProgressRenderingOutput } from "../../project-definition/output-defaults.ts";
@@ -15,6 +15,7 @@ export interface ProgressWriter {
 export type ProgressFeedback = Readonly<
   | {
       readonly kind: "prepared";
+      readonly quietPassOmissionConfiguredCount: number;
       readonly totalChecks: number;
     }
   | {
@@ -24,6 +25,7 @@ export type ProgressFeedback = Readonly<
       readonly kind: "started";
       readonly checkId: string;
       readonly displayName: string;
+      readonly omitQuietPassedRow: boolean;
     }
   | {
       readonly kind: "settled";
@@ -31,7 +33,7 @@ export type ProgressFeedback = Readonly<
       readonly displayName: string;
       readonly outcome: CheckOutcome;
       readonly durationMs: number | null;
-      readonly visibility: CheckVisibility;
+      readonly omitQuietPassedRow: boolean;
       readonly messages: readonly CheckMessage[];
       readonly records: readonly CoreRecord[];
     }
@@ -73,7 +75,11 @@ export function createProgressRenderer(
   const controller = new ProgressRendererController(writer, clock, progressRendering);
   return Object.freeze({
     refreshesRunningRegion: controller.refreshesRunningRegion,
-    refresh: (): void => controller.refresh(),
-    render: (feedback: ProgressFeedback): void => controller.render(feedback)
+    refresh: (): void => {
+      controller.refresh();
+    },
+    render: (feedback: ProgressFeedback): void => {
+      controller.render(feedback);
+    }
   });
 }

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

@@ -1,12 +1,16 @@
-import type { CheckProjectContext } from "../check/check.ts";
-import type { RunControls } from "./controls/contract.ts";
+import type { CheckProjectContext, ProjectChanges } from "../check/check.ts";
 import type { ResolvedInvocationPaths } from "./invocation/paths.ts";
 /** Materializes only invocation-wide callback input; Check-local options own domain configuration. */
 export function createProjectContext(
-  input: Readonly<{ readonly controls: RunControls; readonly paths: ResolvedInvocationPaths }>
+  input: Readonly<{
+    readonly changes?: ProjectChanges;
+    readonly flags: readonly string[];
+    readonly paths: ResolvedInvocationPaths;
+  }>
 ): CheckProjectContext {
   return Object.freeze({
-    flags: Object.freeze([...(input.controls.flags ?? [])]),
+    ...(input.changes === undefined ? {} : { changes: input.changes }),
+    flags: input.flags,
     root: input.paths.projectRoot
   });
 }

package/src/project-run/result.ts

@@ -41,8 +41,8 @@ export interface CheckRunMessage {
 
 /** 只有已形成 terminal Check facts 的 Run branch 才具备的完整结果 readback。 */
 export interface RunResultFacts {
-  /** 调用方未配置 aggregation 时为 `null`；否则是选中 Check statuses 的 invocation-level conclusion。 */
-  readonly aggregate: CheckAggregate | null;
+  /** 有完整 terminal Check facts 时，由有效 Check 列表形成的 invocation-level conclusion。 */
+  readonly aggregate: CheckAggregate;
   /** 按 canonical Check order 的 duration facts；未执行 Check 仍以 `null` 保留。 */
   readonly checkDurations: readonly CheckDuration[];
   /** 已接受的 author 与 console-capture messages，不决定 Check outcome。 */
@@ -122,7 +122,7 @@ export type RunResult = Readonly<
           | "machine-publication-failed"
           | "progress-rendering-failed"
           | "diagnostic-logging-failed"
-          | "scheduler-measurement-hooks-failed";
+          | "scheduler-terminal-effects-failed";
       }>;
       readonly outputs: RunOutputStatuses;
     } & RunResultFacts)
@@ -159,8 +159,8 @@ function outputDiagnosticCode(
       return "progress-rendering-failed";
     case "diagnosticLogging":
       return "diagnostic-logging-failed";
-    case "measurementHooks":
-      return "scheduler-measurement-hooks-failed";
+    case "terminalEffects":
+      return "scheduler-terminal-effects-failed";
   }
 }
 

package/src/project-run/run.ts

@@ -15,7 +15,7 @@ export type { RunDiagnostic, RunResult } from "./result.ts";
  * @param controls - 本次 invocation context 与 outputs 使用的闭合控制值。
  * @returns ordinary configuration、planning、execution、cancellation 与 output failures 通过 `RunResult`
  * 返回；调用方先按 `kind` narrow。
- * @remarks Definition validation 关闭 authoring grammar；可选 Check preflight 在其 Task 通过直接 relation
+ * @remarks Definition validation 关闭 authoring grammar；可选 Check preparation 在其 Task 通过直接 relation
  * readiness 后被 Scheduler admission 时运行，并先于该 Check 自己的 execution callback。它受该 Task 的
  * mutex、capacity、priority 与 cancellation 约束，而不是 invocation-wide barrier。`output` branch 同时提供
  * 完整 final snapshot 与 output failure diagnostic。

package/src/project-run/task-scheduler/admission-core/compiled-graph-lookup.ts

@@ -0,0 +1,71 @@
+/** Required accessors for compiler-owned dense slot indexes. */
+
+import type { PlannedTask } from "../graph.ts";
+import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+
+export function requiredTaskForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): PlannedTask {
+  const task = compiled.graph.tasks[taskSlot];
+  if (task === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return task;
+}
+
+export function requiredTaskMutexSlotsForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): CompiledAdmissionGraph["taskMutexSlots"][number] {
+  const slots = compiled.taskMutexSlots[taskSlot];
+  if (slots === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return slots;
+}
+
+export function requiredTaskResourceClaimsForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): CompiledAdmissionGraph["taskResourceClaims"][number] {
+  const claims = compiled.taskResourceClaims[taskSlot];
+  if (claims === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return claims;
+}
+
+export function requiredReverseDependenciesForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): CompiledAdmissionGraph["relationIndexes"]["reverseDependencies"][number] {
+  const dependencies = compiled.relationIndexes.reverseDependencies[taskSlot];
+  if (dependencies === undefined)
+    throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return dependencies;
+}
+
+export function requiredReverseObservationsForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): CompiledAdmissionGraph["relationIndexes"]["reverseObservations"][number] {
+  const observations = compiled.relationIndexes.reverseObservations[taskSlot];
+  if (observations === undefined)
+    throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return observations;
+}
+
+export function requiredReverseMutexOccurrencesForCompiled(
+  compiled: CompiledAdmissionGraph,
+  mutexSlot: number
+): CompiledAdmissionGraph["relationIndexes"]["reverseMutexOccurrences"][number] {
+  const occurrences = compiled.relationIndexes.reverseMutexOccurrences[mutexSlot];
+  if (occurrences === undefined) {
+    throw new Error(`admission core mutex slot is unknown: ${mutexSlot}`);
+  }
+  return occurrences;
+}
+
+export function requiredScopeTerminalSlotsForCompiled(
+  compiled: CompiledAdmissionGraph,
+  taskSlot: number
+): CompiledAdmissionGraph["scopeSlotsByTerminalTaskSlot"][number] {
+  const scopeSlots = compiled.scopeSlotsByTerminalTaskSlot[taskSlot];
+  if (scopeSlots === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+  return scopeSlots;
+}

package/src/project-run/task-scheduler/admission-core/compiled-graph.ts

@@ -252,12 +252,17 @@ function compilePublicTaskOrder(
   graph: PlannedTaskGraph,
   taskSlotsById: ReadonlyMap<string, number>
 ): PublicTaskOrder {
+  const taskIdsInPublicOrder = Object.freeze(graph.tasks.map((task) => task.id).sort(compareText));
   return {
-    taskIdsInPublicOrder: Object.freeze(graph.tasks.map((task) => task.id).sort(compareText)),
+    taskIdsInPublicOrder,
     taskSlotsInPublicOrder: Object.freeze(
-      graph.tasks
-        .map((task) => taskSlotsById.get(task.id)!)
-        .sort((left, right) => compareText(graph.tasks[left].id, graph.tasks[right].id))
+      taskIdsInPublicOrder.map((taskId) => {
+        const taskSlot = taskSlotsById.get(taskId);
+        if (taskSlot === undefined) {
+          throw new Error(`admission core task is missing from public order: ${taskId}`);
+        }
+        return taskSlot;
+      })
     )
   };
 }

package/src/project-run/task-scheduler/admission-core/selection-query.ts

@@ -1,5 +1,9 @@
 import type { AdmissionSelectionRejectionReason } from "../../../project-definition/scheduler-policy.ts";
 import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import {
+  requiredTaskForCompiled,
+  requiredTaskResourceClaimsForCompiled
+} from "./compiled-graph-lookup.ts";
 import {
   numberFor,
   statusForSelection,
@@ -32,9 +36,7 @@ export function isCoreComplete(state: SelectionCoreState): boolean {
 }
 
 export function requiredTaskForCore(state: SelectionCoreState, taskSlot: number): PlannedTask {
-  const task = state.compiled.graph.tasks[taskSlot];
-  if (task === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);
-  return task;
+  return requiredTaskForCompiled(state.compiled, taskSlot);
 }
 
 export function requiredTaskSlotForCore(state: SelectionCoreState, taskId: string): number {
@@ -165,7 +167,7 @@ function resourceCapacityRejectionFor(
     AdmissionSelectionRejectionReason,
     { readonly kind: "resource-capacity-insufficient" }
   >["resources"][number][] = [];
-  for (const claim of state.compiled.taskResourceClaims[taskSlot]) {
+  for (const claim of requiredTaskResourceClaimsForCompiled(state.compiled, taskSlot)) {
     const capacity = state.compiled.resourceCapacityBySlot[claim.resourceSlot];
     const inUse = numberFor(state.selection.resourceInUse, claim.resourceSlot);
     if (capacity === undefined) {

package/src/project-run/task-scheduler/admission-core/selection-seed.ts

@@ -1,4 +1,8 @@
 import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import {
+  requiredTaskMutexSlotsForCompiled,
+  requiredTaskResourceClaimsForCompiled
+} from "./compiled-graph-lookup.ts";
 import {
   forcedQueueFromTaskSlots,
   freezeSelectionIndex,
@@ -68,9 +72,11 @@ function seedTaskCounters(
     if (status.kind === "pending" || status.kind === "running") remainingTaskCount += 1;
     if (status.kind === "running") {
       runningTotal += 1;
-      for (const mutexSlot of compiled.taskMutexSlots[taskSlot]) mutexHolders[mutexSlot] += 1;
-      for (const claim of compiled.taskResourceClaims[taskSlot]) {
-        resourceInUse[claim.resourceSlot] += claim.units;
+      for (const mutexSlot of requiredTaskMutexSlotsForCompiled(compiled, taskSlot)) {
+        incrementCounter(mutexHolders, mutexSlot, 1, "mutex holder");
+      }
+      for (const claim of requiredTaskResourceClaimsForCompiled(compiled, taskSlot)) {
+        incrementCounter(resourceInUse, claim.resourceSlot, claim.units, "resource usage");
       }
     }
     appendDependencyCountsForSeed(
@@ -140,14 +146,38 @@ function heldMutexBlockersForSeed(
   const blockers = compiled.graph.tasks.map(() => 0);
   const legacyHeldMutexes = new Set(legacyRunningMutexes);
   for (const [taskSlot, task] of compiled.graph.tasks.entries()) {
-    for (const [mutexOccurrence, mutexSlot] of compiled.taskMutexSlots[taskSlot].entries()) {
-      blockers[taskSlot] += mutexHolders[mutexSlot];
-      if (legacyHeldMutexes.has(task.mutex[mutexOccurrence])) blockers[taskSlot] += 1;
+    for (const [mutexOccurrence, mutexSlot] of requiredTaskMutexSlotsForCompiled(
+      compiled,
+      taskSlot
+    ).entries()) {
+      const holderCount = mutexHolders[mutexSlot];
+      if (holderCount === undefined) {
+        throw new Error(`admission core mutex slot is unknown: ${mutexSlot}`);
+      }
+      incrementCounter(blockers, taskSlot, holderCount, "mutex blocker");
+      const mutexId = task.mutex[mutexOccurrence];
+      if (mutexId === undefined) {
+        throw new Error(`admission core mutex occurrence is unknown: ${mutexOccurrence}`);
+      }
+      if (legacyHeldMutexes.has(mutexId)) incrementCounter(blockers, taskSlot, 1, "mutex blocker");
     }
   }
   return blockers;
 }
 
+function incrementCounter(
+  values: number[],
+  slot: number,
+  amount: number,
+  counterName: string
+): void {
+  const current = values[slot];
+  if (current === undefined) {
+    throw new Error(`admission core ${counterName} slot is unknown: ${slot}`);
+  }
+  values[slot] = current + amount;
+}
+
 function seedActiveScopes(
   compiled: CompiledAdmissionGraph,
   activeScopeIds: readonly string[] | undefined

package/src/project-run/task-scheduler/admission-core/selection-transition.ts

@@ -1,4 +1,12 @@
 import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import {
+  requiredReverseDependenciesForCompiled,
+  requiredReverseMutexOccurrencesForCompiled,
+  requiredReverseObservationsForCompiled,
+  requiredScopeTerminalSlotsForCompiled,
+  requiredTaskMutexSlotsForCompiled,
+  requiredTaskResourceClaimsForCompiled
+} from "./compiled-graph-lookup.ts";
 import {
   enqueueForcedTaskSlots,
   freezeSelectionIndex,
@@ -124,7 +132,7 @@ function withResourceClaimDelta(
 ): NumberStore {
   return withNumberDeltas(
     resourceInUse,
-    compiled.taskResourceClaims[taskSlot].map(
+    requiredTaskResourceClaimsForCompiled(compiled, taskSlot).map(
       ({ resourceSlot, units }) => [resourceSlot, direction * units] as const
     )
   );
@@ -138,7 +146,9 @@ function withMutexHolderDelta(
 ): NumberStore {
   return withNumberDeltas(
     mutexHolders,
-    compiled.taskMutexSlots[taskSlot].map((mutexSlot) => [mutexSlot, delta] as const)
+    requiredTaskMutexSlotsForCompiled(compiled, taskSlot).map(
+      (mutexSlot) => [mutexSlot, delta] as const
+    )
   );
 }
 
@@ -157,9 +167,8 @@ function mutexBlockerDeltasFor(
   delta: 1 | -1
 ): readonly (readonly [number, number])[] {
   const deltas: [number, number][] = [];
-  for (const mutexSlot of compiled.taskMutexSlots[taskSlot]) {
-    for (const blockedTaskSlot of compiled.relationIndexes.reverseMutexOccurrences[mutexSlot] ??
-      []) {
+  for (const mutexSlot of requiredTaskMutexSlotsForCompiled(compiled, taskSlot)) {
+    for (const blockedTaskSlot of requiredReverseMutexOccurrencesForCompiled(compiled, mutexSlot)) {
       deltas.push([blockedTaskSlot, delta]);
     }
   }
@@ -173,7 +182,7 @@ function applySettlementRelationDelta(
 ): void {
   const { previous, status, taskSlot } = facts;
   if (previous.kind === "settled" || status.kind !== "settled") return;
-  const reverseDependencies = compiled.relationIndexes.reverseDependencies[taskSlot];
+  const reverseDependencies = requiredReverseDependenciesForCompiled(compiled, taskSlot);
   facts.pendingDependencies = withNumberDeltas(
     facts.pendingDependencies,
     reverseDependencies.map((dependentSlot) => [dependentSlot, -1] as const)
@@ -186,7 +195,7 @@ function applySettlementRelationDelta(
   }
   facts.pendingObservations = withNumberDeltas(
     facts.pendingObservations,
-    compiled.relationIndexes.reverseObservations[taskSlot].map(
+    requiredReverseObservationsForCompiled(compiled, taskSlot).map(
       (observerSlot) => [observerSlot, -1] as const
     )
   );
@@ -228,7 +237,7 @@ function applyScopeLifecycleDelta(
     );
   }
   if (previous.kind === "settled" || status.kind !== "settled") return;
-  for (const scopeSlot of compiled.scopeSlotsByTerminalTaskSlot[taskSlot]) {
+  for (const scopeSlot of requiredScopeTerminalSlotsForCompiled(compiled, taskSlot)) {
     facts.activeScopeSlots = Object.freeze(
       facts.activeScopeSlots.filter((candidate) => candidate !== scopeSlot)
     );

package/src/project-run/task-scheduler/execution-state.ts

@@ -1,6 +1,6 @@
 import type {
   SchedulerMeasurementContext,
-  SchedulerMeasurementHook
+  SchedulerTerminalEffect
 } from "../../project-definition/project-definition.ts";
 import type { PlannedTask, PlannedTaskGraph, PlannedTaskScope, TaskGraph } from "./graph.ts";
 import {
@@ -63,9 +63,9 @@ export interface RunTaskGraphOptions<TResult> {
   /** Explicit enabled-only handoff; no Scheduler behavior is inferred from a logger shape. */
   readonly performanceDiagnostics?: SchedulerPerformanceDiagnosticsInput;
   /** Runtime-only terminal consumers; their context is formed after Scheduler drain. */
-  readonly measurementHooks?: readonly SchedulerMeasurementHook[];
-  readonly onMeasurementHookFailure?: () => void;
-  readonly onMeasurementHooksSettled?: () => void;
+  readonly terminalEffects?: readonly SchedulerTerminalEffect[];
+  readonly onTerminalEffectFailure?: () => void;
+  readonly onTerminalEffectsSettled?: () => void;
   /** Product-private test observer; no package consumer can supply this through `run`. */
   readonly onAdmissionCoreEffect?: (effect: SchedulerAdmissionCoreEffect) => void;
   readonly graph: TaskGraph;

package/src/project-run/task-scheduler/measurement/diagnostics.ts

@@ -3,7 +3,7 @@ import type {
   SchedulerDecisionMeasurementCumulative,
   SchedulerMeasurementAdmission,
   SchedulerMeasurementEffect,
-  SchedulerMeasurementHook,
+  SchedulerTerminalEffect,
   SchedulerRawMeasurement
 } from "../../../project-definition/project-definition.ts";
 import { diagnosticTags, type DiagnosticLogger } from "../../diagnostic-logging/logger.ts";
@@ -75,7 +75,10 @@ export class SchedulerPerformanceDiagnostics {
     const boundary = this.#timing.boundary();
     if (boundary === undefined) return;
     const admissionDelay = this.#timing.takeAdmissionDelay(taskId);
-    if (admissionDelay === undefined) return this.#timing.invalidate("integral-invalid");
+    if (admissionDelay === undefined) {
+      this.#timing.invalidate("integral-invalid");
+      return;
+    }
     this.#chronologyByTaskId.set(taskId, {
       admissionDelay,
       admittedAt: boundary,
@@ -97,7 +100,10 @@ export class SchedulerPerformanceDiagnostics {
     if (boundary === undefined) return;
     this.#timing.closeAcceptedWait(boundary);
     const chronology = this.#chronologyByTaskId.get(taskId);
-    if (chronology === undefined) return this.#timing.invalidate("integral-invalid");
+    if (chronology === undefined) {
+      this.#timing.invalidate("integral-invalid");
+      return;
+    }
     chronology.settledAt = boundary;
   }
 
@@ -141,7 +147,7 @@ export class SchedulerPerformanceDiagnostics {
   }
 
   /** Internal default terminal hook; it contains writer failure without runner special-casing. */
-  public defaultSummaryHook(): SchedulerMeasurementHook | undefined {
+  public defaultSummaryHook(): SchedulerTerminalEffect | undefined {
     if (this.#logger === undefined) return undefined;
     const logger = this.#logger;
     return (context) => {

package/src/project-run/task-scheduler/measurement/timing.ts

@@ -27,7 +27,7 @@ export class SchedulerPerformanceTiming {
   readonly #clock: Readonly<{ now(): number }>;
   readonly #integrals = new SchedulerPerformanceIntegrals();
   #lastBoundaryAt: number | undefined;
-  #startedAt: number | undefined;
+  readonly #startedAt: number | undefined;
   #lastState: SchedulerPerformanceState;
   #timing: SchedulerMeasurementTiming = Object.freeze({ availability: "available" });
   #controlPathMs = 0;
@@ -137,13 +137,18 @@ export class SchedulerPerformanceTiming {
     if (this.#timing.availability === "unavailable") return undefined;
     try {
       const now = this.#clock.now();
-      if (!Number.isFinite(now)) return this.#unavailable("clock-non-finite");
+      if (!Number.isFinite(now)) {
+        this.#unavailable("clock-non-finite");
+        return undefined;
+      }
       if (this.#lastBoundaryAt !== undefined && now < this.#lastBoundaryAt) {
-        return this.#unavailable("clock-backward");
+        this.#unavailable("clock-backward");
+        return undefined;
       }
       return now;
     } catch {
-      return this.#unavailable("clock-threw");
+      this.#unavailable("clock-threw");
+      return undefined;
     }
   }
 
@@ -154,7 +159,10 @@ export class SchedulerPerformanceTiming {
   ): void {
     if (startedAt === undefined || endedAt === undefined) return;
     const elapsedMs = endedAt - startedAt;
-    if (!validElapsed(elapsedMs)) return this.#markUnavailable("interval-invalid");
+    if (!validElapsed(elapsedMs)) {
+      this.#markUnavailable("interval-invalid");
+      return;
+    }
     if (kind === "control") this.#controlPathMs += elapsedMs;
     else this.#decisionObservationMs += elapsedMs;
     if (!Number.isFinite(this.#controlPathMs) || !Number.isFinite(this.#decisionObservationMs)) {

package/src/project-run/task-scheduler/scheduler-observation.ts

@@ -36,7 +36,9 @@ export function observeSchedulerDecision<TResult>(
     tags: schedulerDecisionTags(decision),
     details: schedulerDecisionDetails(decision)
   };
-  const observe = () => observeSchedulerDiagnostic(state, observation);
+  const observe = () => {
+    observeSchedulerDiagnostic(state, observation);
+  };
   if (diagnostics === undefined) observe();
   else diagnostics.observeDecision(observe);
 }

package/src/project-run/task-scheduler/scheduler-terminal-measurement.ts

@@ -1,6 +1,6 @@
 import type {
   SchedulerMeasurementContext,
-  SchedulerMeasurementHook,
+  SchedulerTerminalEffect,
   SchedulerRawMeasurement
 } from "../../project-definition/project-definition.ts";
 import { diagnosticTags } from "../diagnostic-logging/logger.ts";
@@ -8,7 +8,7 @@ import type { RunTaskGraphOptions, SchedulerState } from "./execution-state.ts";
 import type { SchedulerPerformanceDiagnostics } from "./measurement/diagnostics.ts";
 import { observeSchedulerDiagnostic } from "./scheduler-observation.ts";
 
-/** Delivers the terminal measurement to the internal summary and caller hooks exactly once. */
+/** Delivers the terminal measurement to the internal summary and caller effects exactly once. */
 export async function observeTerminalMeasurement<TResult>(
   input: Readonly<{
     readonly diagnostics: SchedulerPerformanceDiagnostics;
@@ -22,32 +22,34 @@ export async function observeTerminalMeasurement<TResult>(
     input.diagnostics.admittedTaskIds(),
     input.diagnostics.rawMeasurement()
   );
-  const callerHooks = input.options.measurementHooks ?? [];
-  let callerHookFailed = false;
-  const callerFailure = () => {
-    callerHookFailed = true;
+  const callerEffects = input.options.terminalEffects ?? [];
+  let callerEffectFailed = false;
+  const reportCallerEffectFailure = () => {
+    callerEffectFailed = true;
     observeSchedulerDiagnostic(input.state, {
-      event: "scheduler.measurement-hook-failed",
-      tags: diagnosticTags("MEASUREMENT_HOOK_FAILED"),
+      event: "scheduler.terminal-effect-failed",
+      tags: diagnosticTags("TERMINAL_EFFECT_FAILED"),
       details: Object.freeze({})
     });
     try {
-      input.options.onMeasurementHookFailure?.();
+      input.options.onTerminalEffectFailure?.();
     } catch {
       // A failure-reporting seam cannot revise terminal Scheduler facts either.
     }
   };
-  const defaultHook = input.diagnostics.defaultSummaryHook();
-  const deliveries: readonly TerminalMeasurementDelivery[] = Object.freeze([
-    ...(defaultHook === undefined
+  const defaultSummaryEffect = input.diagnostics.defaultSummaryHook();
+  const deliveries: readonly TerminalEffectDelivery[] = Object.freeze([
+    ...(defaultSummaryEffect === undefined
       ? []
-      : [Object.freeze({ hook: defaultHook, onFailure: () => undefined })]),
-    ...callerHooks.map((hook) => Object.freeze({ hook, onFailure: callerFailure }))
+      : [Object.freeze({ effect: defaultSummaryEffect, onFailure: () => undefined })]),
+    ...callerEffects.map((effect) =>
+      Object.freeze({ effect, onFailure: reportCallerEffectFailure })
+    )
   ]);
-  await deliverTerminalMeasurementHooks(deliveries, context);
-  if (callerHooks.length > 0 && !callerHookFailed) {
+  await deliverTerminalEffects(deliveries, context);
+  if (callerEffects.length > 0 && !callerEffectFailed) {
     try {
-      input.options.onMeasurementHooksSettled?.();
+      input.options.onTerminalEffectsSettled?.();
     } catch {
       // A success-reporting seam cannot revise terminal Scheduler facts either.
     }
@@ -55,18 +57,18 @@ export async function observeTerminalMeasurement<TResult>(
   return context;
 }
 
-type TerminalMeasurementDelivery = Readonly<{
-  readonly hook: SchedulerMeasurementHook;
+type TerminalEffectDelivery = Readonly<{
+  readonly effect: SchedulerTerminalEffect;
   readonly onFailure: () => void;
 }>;
 
-async function deliverTerminalMeasurementHooks(
-  deliveries: readonly TerminalMeasurementDelivery[],
+async function deliverTerminalEffects(
+  deliveries: readonly TerminalEffectDelivery[],
   context: SchedulerMeasurementContext
 ): Promise<void> {
   for (const delivery of deliveries) {
     try {
-      await delivery.hook(context);
+      await delivery.effect(context);
     } catch {
       delivery.onFailure();
     }

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

@@ -99,7 +99,10 @@ export async function runTaskGraph<TResult>(
       state.admissionCore = cancellation.state;
       diagnostics?.beforePendingSettlement(state.pending.map((task) => task.id));
       if (diagnostics === undefined) applyAdmissionPolicyFault(state, error);
-      else diagnostics.measureControlPath(() => applyAdmissionPolicyFault(state, error));
+      else
+        diagnostics.measureControlPath(() => {
+          applyAdmissionPolicyFault(state, error);
+        });
       diagnostics?.captureState(performanceState(state));
       observeAdmissionPolicyFault(state, error);
       trigger = Object.freeze({ kind: "cancellation-applied" });
@@ -116,7 +119,9 @@ export async function runTaskGraph<TResult>(
           const lifecycleFault = new AdmissionPolicyFault("lifecycle-invalid-select");
           if (diagnostics === undefined) applyAdmissionPolicyFault(state, lifecycleFault);
           else
-            diagnostics.measureControlPath(() => applyAdmissionPolicyFault(state, lifecycleFault));
+            diagnostics.measureControlPath(() => {
+              applyAdmissionPolicyFault(state, lifecycleFault);
+            });
           diagnostics?.captureState(performanceState(state));
           observeAdmissionPolicyFault(state, lifecycleFault);
           trigger = Object.freeze({ kind: "cancellation-applied" });
@@ -133,7 +138,10 @@ export async function runTaskGraph<TResult>(
         state.admissionCore = selection.transition.state;
         diagnostics?.beforeAdmission(decision.taskId, [...state.runningById.keys()]);
         if (diagnostics === undefined) applyAdmission(state, decision);
-        else diagnostics.measureControlPath(() => applyAdmission(state, decision));
+        else
+          diagnostics.measureControlPath(() => {
+            applyAdmission(state, decision);
+          });
         diagnostics?.captureState(performanceState(state));
         if (state.admissionPolicy.requiresMeasurement === true) {
           diagnostics?.beginSelectedPolicyAction(decision.taskId);
@@ -146,7 +154,10 @@ export async function runTaskGraph<TResult>(
       case "settle-blocked":
         diagnostics?.beforePendingSettlement([decision.taskId]);
         if (diagnostics === undefined) applyBlockedSettlement(state, decision);
-        else diagnostics.measureControlPath(() => applyBlockedSettlement(state, decision));
+        else
+          diagnostics.measureControlPath(() => {
+            applyBlockedSettlement(state, decision);
+          });
         diagnostics?.captureState(performanceState(state));
         diagnostics?.recordEffect(
           Object.freeze({
@@ -164,7 +175,10 @@ export async function runTaskGraph<TResult>(
         state.admissionCore = cancelPendingAdmissionCore(state.admissionCore).state;
         diagnostics?.beforePendingSettlement(decision.taskIds);
         if (diagnostics === undefined) applyCancellation(state, decision);
-        else diagnostics.measureControlPath(() => applyCancellation(state, decision));
+        else
+          diagnostics.measureControlPath(() => {
+            applyCancellation(state, decision);
+          });
         diagnostics?.captureState(performanceState(state));
         for (const taskId of decision.taskIds) {
           diagnostics?.recordEffect(
@@ -187,7 +201,10 @@ export async function runTaskGraph<TResult>(
         const completion = await nextRunningSettlement(state);
         diagnostics?.beforeRunningSettlement(completion.taskId);
         if (diagnostics === undefined) settleRunningTask(state, completion);
-        else diagnostics.measureControlPath(() => settleRunningTask(state, completion));
+        else
+          diagnostics.measureControlPath(() => {
+            settleRunningTask(state, completion);
+          });
         const settlementKind = completion.settlement.kind;
         if (
           settlementKind !== "completed" &&