@zxyycom/vibe-check 0.0.1 → 0.0.3

package/types/project-run/task-scheduler/admission-core/selection-index.d.ts

@@ -0,0 +1,61 @@
+import { List } from "immutable";
+import type { SchedulerSettlementKind } from "../scheduler-decision-model.ts";
+export type CoreTaskStatus = Readonly<{
+    readonly kind: "pending";
+}>
+/** Only used while adapting private partial SchedulerSnapshot test inputs. */
+ | Readonly<{
+    readonly kind: "absent";
+}> | Readonly<{
+    readonly kind: "running";
+}> | Readonly<{
+    readonly kind: "settled";
+    readonly settlementKind: SchedulerSettlementKind;
+}>;
+export declare const PENDING: CoreTaskStatus;
+export declare const ABSENT: CoreTaskStatus;
+/** Immutable.List is the persistent indexed backing for every dense selection counter. */
+export type PersistentIndexedStore<T> = Readonly<{
+    readonly values: List<T>;
+}>;
+export type NumberStore = PersistentIndexedStore<number>;
+export type StatusStore = PersistentIndexedStore<CoreTaskStatus>;
+/** Persistent leftist max-heap: task slots are the canonical forced-effect priority. */
+export type ForcedTaskQueue = undefined | Readonly<{
+    readonly left: ForcedTaskQueue;
+    readonly rank: number;
+    readonly right: ForcedTaskQueue;
+    readonly taskSlot: number;
+}>;
+/** Private dynamic index shared by the seed, delta reducer and read-only query owners. */
+export interface AdmissionSelectionIndex {
+    readonly activeScopeSlots: readonly number[];
+    readonly activeScopes: NumberStore;
+    readonly forcedQueue: ForcedTaskQueue;
+    readonly legacyRunningMutexes: readonly string[] | undefined;
+    readonly mutexHolders: NumberStore;
+    /** Per-task reverse-mutex occurrence count; candidate sieving never builds mutex payloads. */
+    readonly heldMutexBlockers: NumberStore;
+    readonly nonCompletedDependencies: NumberStore;
+    readonly pendingObservations: NumberStore;
+    readonly pendingDependencies: NumberStore;
+    readonly remainingTaskCount: number;
+    readonly resourceInUse: NumberStore;
+    readonly runningTotal: number;
+    readonly statuses: StatusStore;
+}
+export declare function persistentStatuses(values: readonly CoreTaskStatus[]): StatusStore;
+export declare function persistentNumbersFor(values: readonly number[]): NumberStore;
+export declare function statusForSelection(selection: AdmissionSelectionIndex, taskSlot: number): CoreTaskStatus;
+export declare function statusForStore(store: StatusStore, taskSlot: number): CoreTaskStatus;
+export declare function withStatusAt(store: StatusStore, taskSlot: number, value: CoreTaskStatus): StatusStore;
+export declare function numberFor(store: NumberStore, slot: number): number;
+/** Applies all occurrence deltas through one new persistent List value. */
+export declare function withNumberDeltas(store: NumberStore, deltas: readonly (readonly [number, number])[]): NumberStore;
+export declare function forcedTaskSlotFor(selection: AdmissionSelectionIndex): number | undefined;
+/** Removes just the persistent heap root; all retained branches remain shared. */
+export declare function withoutForcedTask(selection: AdmissionSelectionIndex): AdmissionSelectionIndex;
+export declare function forcedQueueFromTaskSlots(taskSlots: readonly number[]): ForcedTaskQueue;
+/** Additions are newly-ready reverse dependents, so no extant frontier is copied or sorted. */
+export declare function enqueueForcedTaskSlots(existing: ForcedTaskQueue, additions: ReadonlySet<number>): ForcedTaskQueue;
+export declare function freezeSelectionIndex(selection: AdmissionSelectionIndex): AdmissionSelectionIndex;

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

@@ -0,0 +1,28 @@
+import type { AdmissionSelectionRejectionReason } from "../../../project-definition/scheduler-policy.ts";
+import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import { type AdmissionSelectionIndex, type CoreTaskStatus } from "./selection-index.ts";
+import type { PlannedTask, PlannedTaskGraph } from "../graph.ts";
+type SelectionCoreState = Readonly<{
+    readonly compiled: CompiledAdmissionGraph;
+    readonly selection: AdmissionSelectionIndex;
+}>;
+export interface AdmissionCoreSelection {
+    readonly canAdmit: boolean;
+    readonly task: PlannedTask;
+}
+export declare function statusForCore(state: SelectionCoreState, taskSlot: number): CoreTaskStatus;
+export declare function isCoreComplete(state: SelectionCoreState): boolean;
+export declare function requiredTaskForCore(state: SelectionCoreState, taskSlot: number): PlannedTask;
+export declare function requiredTaskSlotForCore(state: SelectionCoreState, taskId: string): number;
+export declare function requiredScopeForCore(state: SelectionCoreState, scopeSlot: number): PlannedTaskGraph["scopes"][number];
+export declare function requiredScopeSlotForCore(state: SelectionCoreState, scopeId: string): number;
+/** Public validation and catalog payloads preserve lexical duplicate occurrences. */
+export declare function selectionRejectionForPendingTask(state: SelectionCoreState, taskSlot: number): AdmissionSelectionRejectionReason | undefined;
+export declare function isAdmissionEligibleForPendingTask(state: SelectionCoreState, taskSlot: number): boolean;
+export declare function admissionCandidatesForCore(state: SelectionCoreState): readonly AdmissionCoreSelection[];
+export declare function scopeToActivateForCore(state: SelectionCoreState, taskId: string): string | null;
+export declare function activeScopesForCore(state: SelectionCoreState): PlannedTaskGraph["scopes"][number][];
+export declare function scopeLifecycleForCore(state: SelectionCoreState, scopeSlot: number): "inactive" | "active" | "closed";
+export declare function isScopeInactiveForCore(state: SelectionCoreState, scopeSlot: number): boolean;
+export declare function effectiveMaxParallelForCore(state: SelectionCoreState): number;
+export {};

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

@@ -0,0 +1,9 @@
+import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import { type AdmissionSelectionIndex, type CoreTaskStatus } from "./selection-index.ts";
+/** Builds every immutable selection index from one static graph and one exact status seed. */
+export declare function selectionIndexForSeed(compiled: CompiledAdmissionGraph, statuses: readonly CoreTaskStatus[], activeScopeIds: readonly string[] | undefined, legacyRunningMutexes: readonly string[] | undefined): AdmissionSelectionIndex;
+export declare function insertActiveScopeSlot(compiled: CompiledAdmissionGraph, slots: readonly number[], next: number): readonly number[];
+export declare function sortedActiveScopeSlots(compiled: CompiledAdmissionGraph, slots: readonly number[]): readonly number[];
+export declare function compareScopeCapacityForCompiled(compiled: CompiledAdmissionGraph, left: number, right: number): number;
+export declare function requiredTaskSlotForCompiled(compiled: CompiledAdmissionGraph, taskId: string): number;
+export declare function requiredScopeForCompiled(compiled: CompiledAdmissionGraph, scopeSlot: number): CompiledAdmissionGraph["graph"]["scopes"][number];

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

@@ -0,0 +1,4 @@
+import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import { type AdmissionSelectionIndex, type CoreTaskStatus } from "./selection-index.ts";
+/** Applies one status event through staged persistent index deltas. */
+export declare function transitionIndexedSelection(compiled: CompiledAdmissionGraph, selection: AdmissionSelectionIndex, taskSlot: number, status: CoreTaskStatus, activatedScopeSlot: number | undefined): AdmissionSelectionIndex;

package/types/project-run/task-scheduler/admission-core/selection.d.ts

@@ -0,0 +1,20 @@
+import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import { type AdmissionSelectionIndex } from "./selection-index.ts";
+import type { SchedulerSettlementKind, SchedulerSnapshot } from "../scheduler-decision-model.ts";
+/** Private immutable core passed among Scheduler decision, policy and effect owners. */
+export interface AdmissionCoreState {
+    readonly compiled: CompiledAdmissionGraph;
+    /** Selection representation remains private to this lifecycle module family. */
+    readonly selection: AdmissionSelectionIndex;
+}
+/** Starts from the canonical all-pending selection seed. */
+export declare function createInitialAdmissionCoreState(compiled: CompiledAdmissionGraph): AdmissionCoreState;
+/** Seeds from a shell snapshot without exposing a mutable shell view. */
+export declare function createAdmissionCoreFromSchedulerSnapshot(compiled: CompiledAdmissionGraph, snapshot: SchedulerSnapshot): AdmissionCoreState;
+/** Produces an immutable successor for a validated pending-to-running admission. */
+export declare function admitTaskForCore(state: AdmissionCoreState, taskSlot: number): AdmissionCoreState;
+/** Produces an immutable successor for one already-validated settlement event. */
+export declare function settleTaskForCore(state: AdmissionCoreState, taskSlot: number, settlementKind: SchedulerSettlementKind): AdmissionCoreState;
+/** Pops the forced max-heap before recording its canonical blocked settlement. */
+export declare function settleForcedTaskForCore(state: AdmissionCoreState, taskSlot: number): AdmissionCoreState;
+export declare function nextForcedTaskForCore(state: AdmissionCoreState): number | undefined;

package/types/project-run/task-scheduler/admission-scope-layers.d.ts

@@ -0,0 +1,8 @@
+import type { SchedulerInspection } from "./scheduler-decision-inspection.ts";
+import type { PlannedTask, PlannedTaskGraph, PlannedTaskScope } from "./graph.ts";
+/** Returns the declared scope for one Task without inferring membership from activation state. */
+export declare function scopeForTask(graph: PlannedTaskGraph, task: PlannedTask): PlannedTaskScope | undefined;
+/** Returns the inactive constrained scope that this Task would activate. */
+export declare function tighteningScopeForTask(graph: PlannedTaskGraph, inspection: SchedulerInspection, task: PlannedTask): PlannedTaskScope | undefined;
+/** Reports whether a Task continues an active scope that constrains root parallelism. */
+export declare function isConstrainedScopeContinuation(graph: PlannedTaskGraph, inspection: SchedulerInspection, task: PlannedTask): boolean;

package/types/project-run/task-scheduler/admission-selection-policy.d.ts

@@ -0,0 +1,31 @@
+import type { PlannedTask, PlannedTaskGraph } from "./graph.ts";
+import type { AdmissionCoreState } from "./admission-core/core.ts";
+import type { SchedulerInspection } from "./scheduler-decision-inspection.ts";
+import type { AdmissionPolicyContext, SchedulerGraphSnapshot } from "../../project-definition/project-definition.ts";
+export interface AdmissionCandidate {
+    readonly canAdmit: boolean;
+    readonly task: PlannedTask;
+}
+export interface AdmissionPolicyInput {
+    /** Shared immutable core at this decision boundary; only custom context projects its public handle. */
+    readonly admissionCore: AdmissionCoreState;
+    /** Scheduler-owned decision-boundary measurement, present only for custom policy. */
+    readonly measurement?: AdmissionPolicyContext["measurement"];
+    readonly candidates: readonly AdmissionCandidate[];
+    readonly graph: PlannedTaskGraph;
+    readonly graphSnapshot: SchedulerGraphSnapshot;
+    readonly inspection: SchedulerInspection;
+}
+export type AdmissionPolicyDecision = Readonly<{
+    readonly kind: "select";
+    readonly taskId: string;
+}> | Readonly<{
+    readonly kind: "wait";
+}>;
+/** A Product-private pure admission policy; it receives no executor or mutable scheduler state. */
+export interface AdmissionSelectionPolicy {
+    /** Only custom policies require Scheduler sampling before every callback. */
+    readonly requiresMeasurement?: true;
+    readonly decide: (input: AdmissionPolicyInput) => AdmissionPolicyDecision;
+}
+export declare const staticAdmissionSelectionPolicy: AdmissionSelectionPolicy;

package/types/project-run/task-scheduler/custom-admission-policy.d.ts

@@ -0,0 +1,6 @@
+import type { AdmissionPolicyContext, AdmissionProposal } from "../../project-definition/project-definition.ts";
+import type { AdmissionSelectionPolicy } from "./admission-selection-policy.ts";
+import { type AdmissionPolicyFaultCategory } from "./scheduler-admission-decision.ts";
+/** Adapts the public, trusted callback to the Scheduler's private pure policy seam. */
+export declare function admissionSelectionPolicyFor(decide: (this: void, context: AdmissionPolicyContext) => AdmissionProposal): AdmissionSelectionPolicy;
+export type { AdmissionPolicyFaultCategory };

package/types/project-run/task-scheduler/execution-state.d.ts

@@ -1,9 +1,17 @@
+import type { SchedulerMeasurementContext, SchedulerTerminalEffect } from "../../project-definition/project-definition.ts";
 import type { PlannedTask, PlannedTaskGraph, PlannedTaskScope, TaskGraph } from "./graph.ts";
+import { type AdmissionSelectionPolicy } from "./admission-selection-policy.ts";
 import type { DiagnosticLogger } from "../diagnostic-logging/logger.ts";
 import type { SchedulerSnapshot } from "./scheduler-decision.ts";
+import type { AdmissionPolicyFaultCategory } from "./scheduler-admission-decision.ts";
+import type { SchedulerPerformanceDiagnosticsInput } from "./measurement/diagnostics.ts";
+import { type AdmissionCoreEffect, type AdmissionCoreState } from "./admission-core/core.ts";
 export type TaskSettlement<TResult> = Readonly<{
     readonly kind: "completed";
     readonly value: TResult;
+} | {
+    readonly kind: "prerequisite-unsatisfied";
+    readonly value: TResult;
 } | {
     readonly kind: "failed";
     readonly error: unknown;
@@ -20,17 +28,45 @@ export interface SettledTask<TResult> {
 export interface TaskExecutionContext {
     readonly signal: AbortSignal | undefined;
 }
+export interface PreAdmissionTaskResult<TResult> {
+    readonly taskId: string;
+    readonly value: TResult;
+}
+/** Product-private effect hook used to prove that the real shell replays the shared core. */
+export interface SchedulerAdmissionCoreEffect {
+    readonly effect: AdmissionCoreEffect;
+    readonly state: AdmissionCoreState;
+}
 export interface TaskGraphRun<TResult> {
+    readonly admissionPolicyFault: AdmissionPolicyFaultCategory | undefined;
     readonly cancelled: boolean;
     /** One entry per static graph Task, in static graph order. */
     readonly settlements: readonly SettledTask<TResult>[];
+    /** Product-private terminal facts retained after terminal Hooks have been drained. */
+    readonly terminalMeasurement?: SchedulerMeasurementContext;
 }
 export interface RunTaskGraphOptions<TResult> {
+    /** Product-private policy handoff; package consumers cannot author this through the public API. */
+    readonly admissionPolicy?: AdmissionSelectionPolicy;
     readonly diagnosticLogger?: DiagnosticLogger;
+    /** 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 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;
+    /** Product-private Task results formed without Scheduler admission in the current Run. */
+    readonly preAdmissionTaskResults?: readonly PreAdmissionTaskResult<TResult>[];
     readonly maxParallel: number;
     readonly signal?: AbortSignal;
     readonly execute: (task: PlannedTask, context: TaskExecutionContext) => TResult | Promise<TResult>;
+    /** Maps a completed Task's opaque product value to prerequisite satisfaction. */
+    readonly isPrerequisiteSatisfied?: (value: TResult) => boolean;
+    /** Lets a product close a blocked Task before any terminal observer can be admitted. */
+    readonly onTaskBlocked?: (task: PlannedTask, dependencyIds: readonly string[]) => void;
 }
 export type RunningTaskCompletion<TResult> = Readonly<{
     readonly taskId: string;
@@ -46,18 +82,24 @@ export interface RuntimeScope {
     isActive: boolean;
 }
 export interface SchedulerState<TResult> {
+    /** The shared immutable legality/transition state; Task and Promise ownership remains below. */
+    admissionCore: AdmissionCoreState;
+    readonly admissionPolicy: AdmissionSelectionPolicy;
     readonly diagnosticLogger: DiagnosticLogger | undefined;
     readonly graph: PlannedTaskGraph;
+    readonly isPrerequisiteSatisfied: RunTaskGraphOptions<TResult>["isPrerequisiteSatisfied"];
     readonly maxParallel: number;
     readonly signal: AbortSignal | undefined;
     readonly execute: RunTaskGraphOptions<TResult>["execute"];
+    readonly onTaskBlocked: RunTaskGraphOptions<TResult>["onTaskBlocked"];
+    readonly onAdmissionCoreEffect: RunTaskGraphOptions<TResult>["onAdmissionCoreEffect"];
     readonly pending: PlannedTask[];
     readonly runningById: Map<string, RunningTask<TResult>>;
     readonly runningMutexes: Set<string>;
     readonly settlementsByTaskId: Map<string, TaskSettlement<TResult>>;
     readonly scopesById: ReadonlyMap<string, RuntimeScope>;
-    reservationTaskId: string | undefined;
     isCancelled: boolean;
+    admissionPolicyFault: AdmissionPolicyFaultCategory | undefined;
 }
 export declare function createSchedulerState<TResult>(graph: PlannedTaskGraph, options: RunTaskGraphOptions<TResult>): SchedulerState<TResult>;
 /** Projects mutable execution state into the pure scheduler-decision input. */

package/types/project-run/task-scheduler/forced-block-effect-replay.d.ts

@@ -0,0 +1,9 @@
+import { type AdmissionCoreEffect, type AdmissionCoreState } from "./admission-core/core.ts";
+import type { SchedulerTrigger } from "./scheduler-decision.ts";
+import type { SchedulerState } from "./execution-state.ts";
+import type { SchedulerPerformanceDiagnostics } from "./measurement/diagnostics.ts";
+/**
+ * Adapts only canonical forced blocked effects to the real Scheduler shell.
+ * Direct admission, running settlement, and cancellation remain in the root shell.
+ */
+export declare function replayCoreForcedBlocks<TResult>(state: SchedulerState<TResult>, effects: readonly AdmissionCoreEffect[], effectStates: readonly AdmissionCoreState[], diagnostics: SchedulerPerformanceDiagnostics | undefined, trigger: SchedulerTrigger): void;

package/types/project-run/task-scheduler/graph-validation.d.ts

@@ -1,11 +1,12 @@
-import type { PlannedTask, PlannedTaskScope } from "./graph.ts";
+import type { NamedResourceUnits, PlannedTask, PlannedTaskScope } from "./graph.ts";
 interface PreparedTaskGraphValidationInput {
+    readonly resourceCapacities: readonly NamedResourceUnits[];
     readonly rootMaxParallel: number | undefined;
     readonly scopeById: ReadonlyMap<string, PlannedTaskScope>;
     readonly scopes: readonly PlannedTaskScope[];
     readonly taskById: ReadonlyMap<string, PlannedTask>;
     readonly tasks: readonly PlannedTask[];
 }
-/** Validates dependency and scope relations after graph-shaped input is normalized. */
+/** Validates direct relations and scope structure after graph-shaped input is normalized. */
 export declare function validatePreparedTaskGraph(input: PreparedTaskGraphValidationInput): void;
 export {};

package/types/project-run/task-scheduler/graph.d.ts

@@ -1,7 +1,15 @@
+import type { SchedulerGraphSnapshot } from "../../project-definition/project-definition.ts";
+export interface NamedResourceUnits {
+    readonly resourceId: string;
+    readonly units: number;
+}
 export interface TaskNode {
+    readonly admissionPriority?: number;
     readonly id: string;
     readonly dependsOn?: readonly string[];
     readonly mutex?: readonly string[];
+    readonly observes?: readonly string[];
+    readonly resourceClaims?: Readonly<Record<string, number>>;
     readonly scopeId?: string;
 }
 /**
@@ -16,13 +24,17 @@ export interface TaskScope {
     readonly terminalTaskId: string;
 }
 export interface TaskGraph {
+    readonly resourceCapacities?: Readonly<Record<string, number>>;
     readonly tasks: readonly TaskNode[];
     readonly scopes?: readonly TaskScope[];
 }
 export interface PlannedTask {
+    readonly admissionPriority: number;
     readonly id: string;
     readonly dependsOn: readonly string[];
     readonly mutex: readonly string[];
+    readonly observes: readonly string[];
+    readonly resourceClaims: readonly NamedResourceUnits[];
     readonly scopeId: string | undefined;
 }
 export interface PlannedTaskScope {
@@ -32,6 +44,9 @@ export interface PlannedTaskScope {
     readonly terminalTaskId: string;
 }
 export interface PlannedTaskGraph {
+    readonly resourceCapacities: readonly NamedResourceUnits[];
+    /** Immutable public projection shared by every decision and terminal measurement in one run. */
+    readonly schedulerGraphSnapshot: SchedulerGraphSnapshot;
     readonly tasks: readonly PlannedTask[];
     readonly scopes: readonly PlannedTaskScope[];
 }

package/types/project-run/task-scheduler/measurement/diagnostics.d.ts

@@ -0,0 +1,47 @@
+import type { AdmissionPolicyMeasurement, SchedulerMeasurementEffect, SchedulerTerminalEffect, SchedulerRawMeasurement } from "../../../project-definition/project-definition.ts";
+import { type DiagnosticLogger } from "../../diagnostic-logging/logger.ts";
+/** Explicit, enabled-only private handoff; the Scheduler never infers this from logger behavior. */
+export type SchedulerPerformanceDiagnosticsInput = Readonly<{
+    readonly clock: Readonly<{
+        now(): number;
+    }>;
+    readonly declarativeFingerprint: string;
+    readonly logger?: DiagnosticLogger;
+}>;
+export type AdmissionViablePendingTask = Readonly<{
+    readonly kind: "admissible-pending" | "capacity-blocked" | "mutex-blocked";
+    readonly taskId: string;
+}>;
+export type SchedulerPerformanceState = Readonly<{
+    readonly admissionViablePendingTasks: readonly AdmissionViablePendingTask[];
+    readonly effectiveMaxParallel: number;
+    readonly rootMaxParallel: number;
+    readonly running: number;
+}>;
+/**
+ * Scheduler-owned, invocation-local lifecycle projection. Clock boundaries and
+ * numeric interval accumulation remain private collaborators of this owner.
+ */
+export declare class SchedulerPerformanceDiagnostics {
+    #private;
+    constructor(input: SchedulerPerformanceDiagnosticsInput, initial: SchedulerPerformanceState);
+    measureControlPath<T>(operation: () => T): T;
+    observeDecision(observation: () => void): void;
+    /** Flushes the old state before admission changes the real Scheduler state. */
+    beforeAdmission(taskId: string, runningTaskIds: readonly string[]): void;
+    /** Flushes the old state before blocked/cancelled changes the real Scheduler state. */
+    beforePendingSettlement(taskIds?: readonly string[]): void;
+    /** Flushes the old running interval before removing the actual running Task. */
+    beforeRunningSettlement(taskId: string): void;
+    beforeAcceptedWait(): void;
+    captureState(state: SchedulerPerformanceState): void;
+    rawMeasurement(): SchedulerRawMeasurement;
+    beginSelectedPolicyAction(taskId: string): void;
+    beginWaitPolicyAction(): void;
+    recordEffect(effect: SchedulerMeasurementEffect): void;
+    policyMeasurement(): AdmissionPolicyMeasurement;
+    completePendingActionObservation(): void;
+    admittedTaskIds(): readonly string[];
+    /** Internal default terminal hook; it contains writer failure without runner special-casing. */
+    defaultSummaryHook(): SchedulerTerminalEffect | undefined;
+}

package/types/project-run/task-scheduler/measurement/integrals.d.ts

@@ -0,0 +1,27 @@
+import type { SchedulerMeasurementIntervalContribution } from "../../../project-definition/project-definition.ts";
+import type { AdmissionViablePendingTask, SchedulerPerformanceState } from "./diagnostics.ts";
+export type AdmissionDelayBreakdown = Readonly<{
+    readonly admissiblePendingMs: number;
+    readonly capacityBlockedMs: number;
+    readonly mutexBlockedMs: number;
+}>;
+export type SchedulerPerformancePeaks = Readonly<{
+    readonly admissionViablePendingTaskCount: number;
+    readonly admissiblePendingTaskCount: number;
+    readonly capacityBlockedTaskCount: number;
+    readonly mutexBlockedTaskCount: number;
+}>;
+/** Accumulates interval-weighted capacity and admission-delay measurements. */
+export declare class SchedulerPerformanceIntegrals {
+    #private;
+    installPendingProjection(pendingTasks: readonly AdmissionViablePendingTask[], timingAvailable: boolean): void;
+    /** Returns false when an interval cannot be represented as finite non-negative totals. */
+    addInterval(elapsedMs: number, state: SchedulerPerformanceState): boolean;
+    takeAdmissionDelay(taskId: string): AdmissionDelayBreakdown | undefined;
+    pendingAdmissionDelays(): readonly Readonly<{
+        readonly admissionDelay: AdmissionDelayBreakdown;
+        readonly taskId: string;
+    }>[];
+    peaks(): SchedulerPerformancePeaks;
+    totals(): SchedulerMeasurementIntervalContribution;
+}

package/types/project-run/task-scheduler/measurement/policy.d.ts

@@ -0,0 +1,10 @@
+import type { AdmissionPolicyMeasurement, SchedulerDecisionMeasurementCumulative, SchedulerMeasurementEffect, SchedulerMeasurementIntervalContribution, SchedulerMeasurementTiming } from "../../../project-definition/project-definition.ts";
+/** Owns the immutable prefix of observations formed after accepted custom-policy actions. */
+export declare class SchedulerPolicyMeasurement {
+    #private;
+    beginSelected(taskId: string, baseline: SchedulerMeasurementIntervalContribution): void;
+    beginWait(baseline: SchedulerMeasurementIntervalContribution): void;
+    recordEffect(effect: SchedulerMeasurementEffect): void;
+    complete(totals: SchedulerMeasurementIntervalContribution, timing: SchedulerMeasurementTiming): void;
+    snapshot(cumulative: SchedulerDecisionMeasurementCumulative): AdmissionPolicyMeasurement;
+}

package/types/project-run/task-scheduler/measurement/summary.d.ts

@@ -0,0 +1,3 @@
+import type { SchedulerRawMeasurement } from "../../../project-definition/project-definition.ts";
+/** Projects raw Scheduler measurement into the bounded diagnostic summary. */
+export declare function summaryFromSchedulerMeasurement(raw: SchedulerRawMeasurement): Readonly<Record<string, unknown>>;

package/types/project-run/task-scheduler/measurement/timing.d.ts

@@ -0,0 +1,33 @@
+import type { SchedulerMeasurementIntervalContribution, SchedulerMeasurementTiming, SchedulerMeasurementTimingUnavailableReason } from "../../../project-definition/project-definition.ts";
+import type { SchedulerPerformanceState } from "./diagnostics.ts";
+import { SchedulerPerformanceIntegrals, type AdmissionDelayBreakdown, type SchedulerPerformancePeaks } from "./integrals.ts";
+export type SchedulerPerformanceTimingSnapshot = Readonly<{
+    readonly acceptedWaitCount: number;
+    readonly acceptedWaitMs: number;
+    readonly decisionObservationMs: number;
+    readonly maxRunning: number;
+    readonly peaks: SchedulerPerformancePeaks;
+    readonly schedulerControlPathMs: number;
+    readonly startedAtMonotonicMs: number | undefined;
+    readonly timing: SchedulerMeasurementTiming;
+    readonly totals: SchedulerMeasurementIntervalContribution;
+}>;
+/** Owns monotonic clock boundaries and delegates numeric interval accumulation. */
+export declare class SchedulerPerformanceTiming {
+    #private;
+    constructor(clock: Readonly<{
+        now(): number;
+    }>, initial: SchedulerPerformanceState);
+    /** Accounts a synchronous shell operation, never an await or author callback. */
+    measureControlPath<T>(operation: () => T): T;
+    /** Keeps decision writer work separate from the shell control-path projection. */
+    observeDecision(observation: () => void): void;
+    boundary(): number | undefined;
+    beginAcceptedWait(): void;
+    closeAcceptedWait(boundary: number): void;
+    captureState(state: SchedulerPerformanceState): void;
+    takeAdmissionDelay(taskId: string): AdmissionDelayBreakdown | undefined;
+    pendingAdmissionDelays(): ReturnType<SchedulerPerformanceIntegrals["pendingAdmissionDelays"]>;
+    snapshot(): SchedulerPerformanceTimingSnapshot;
+    invalidate(reason: SchedulerMeasurementTimingUnavailableReason): void;
+}

package/types/project-run/task-scheduler/scheduler-admission-decision.d.ts

@@ -1,8 +1,20 @@
-import { type SchedulerInspection } from "./scheduler-decision-inspection.ts";
+import type { AdmissionPolicyContext } from "../../project-definition/project-definition.ts";
+import type { AdmissionSelectionPolicy } from "./admission-selection-policy.ts";
 import { type SchedulerDecision, type SchedulerDecisionContext, type SchedulerTrigger } from "./scheduler-decision-model.ts";
+import type { SchedulerInspection } from "./scheduler-decision-inspection.ts";
+import { type AdmissionCoreState } from "./admission-core/core.ts";
 export interface SchedulerDecisionCycle {
+    readonly admissionCore: AdmissionCoreState;
     readonly context: SchedulerDecisionContext;
+    readonly policy: AdmissionSelectionPolicy;
+    /** Invoked immediately before the private policy seam enters a custom callback. */
+    readonly measurement?: () => AdmissionPolicyContext["measurement"];
     readonly state: SchedulerInspection;
     readonly trigger: SchedulerTrigger;
 }
 export declare function decideAdmission(cycle: SchedulerDecisionCycle): SchedulerDecision;
+export type AdmissionPolicyFaultCategory = "callback-threw" | "thenable-proposal" | "malformed-proposal" | "non-candidate-select" | "capacity-invalid-select" | "lifecycle-invalid-select" | "undrainable-wait";
+export declare class AdmissionPolicyFault extends Error {
+    readonly category: AdmissionPolicyFaultCategory;
+    constructor(category: AdmissionPolicyFaultCategory);
+}

package/types/project-run/task-scheduler/scheduler-decision-inspection.d.ts

@@ -1,24 +1,25 @@
-import type { PlannedTask, PlannedTaskGraph, PlannedTaskScope } from "./graph.ts";
-import type { SchedulerAwaitReason, SchedulerDecisionContext, SchedulerSettlementKind, SchedulerSnapshot } from "./scheduler-decision-model.ts";
+import type { PlannedTask, PlannedTaskGraph } from "./graph.ts";
+import type { SchedulerGraphSnapshot } from "../../project-definition/project-definition.ts";
+import type { SchedulerCapacity, SchedulerDecisionContext, SchedulerSettlementKind } from "./scheduler-decision-model.ts";
 export interface SchedulerInspection {
-    readonly activeScopeIds: ReadonlySet<string>;
+    readonly activeScopeIds: readonly string[];
     readonly graph: PlannedTaskGraph;
+    readonly isAbortRequested: boolean;
+    readonly isCancelled: boolean;
     readonly maxParallel: number;
     readonly pendingTasks: readonly PlannedTask[];
-    readonly reservationTaskId: string | undefined;
-    readonly runningMutexes: ReadonlySet<string>;
-    readonly runningTaskIds: ReadonlySet<string>;
-    readonly settlementKindByTaskId: ReadonlyMap<string, SchedulerSettlementKind>;
+    readonly runningMutexes: readonly string[];
+    readonly resources: readonly Readonly<{
+        readonly available: number;
+        readonly capacity: number;
+        readonly inUse: number;
+        readonly resourceId: string;
+    }>[];
+    readonly runningTaskIds: readonly string[];
+    readonly settledTasks: readonly Readonly<{
+        readonly kind: SchedulerSettlementKind;
+        readonly taskId: string;
+    }>[];
 }
-export declare function inspectSnapshot(snapshot: SchedulerSnapshot): SchedulerInspection;
-export declare function decisionContext(state: SchedulerInspection): SchedulerDecisionContext;
-export declare function selectBlockedTask(state: SchedulerInspection): Readonly<{
-    readonly dependencyIds: readonly string[];
-    readonly task: PlannedTask;
-}> | undefined;
-export declare function isDependencyMutexEligible(task: PlannedTask, state: SchedulerInspection): boolean;
-export declare function capacityWaitReason(state: SchedulerInspection): SchedulerAwaitReason;
-export declare function canAdmit(state: SchedulerInspection, task: PlannedTask): boolean;
-export declare function activationScopeFor(state: SchedulerInspection, task: PlannedTask): PlannedTaskScope | undefined;
-export declare function selectTighteningTask(state: SchedulerInspection, eligibleTasks: readonly PlannedTask[], effectiveMaxParallel: number): PlannedTask | undefined;
-export declare function selectConstrainedContinuation(state: SchedulerInspection, eligibleTasks: readonly PlannedTask[], effectiveMaxParallel: number): PlannedTask | undefined;
+export declare function decisionContext(state: SchedulerInspection, graphIdentity: SchedulerGraphSnapshot): SchedulerDecisionContext;
+export declare function capacityFor(state: SchedulerInspection): SchedulerCapacity;