@zxyycom/vibe-check 0.0.2 → 0.0.3

package/types/project-definition/check-tree/check-fields-authoring.d.ts

@@ -1,5 +1,6 @@
 import type { CheckDescriptor } from "../../check/descriptor.ts";
-import { type CheckVisibility, type CheckFlagEnablement, type CheckExecution, type CheckPreflight } from "../../check/check.ts";
+import { type Check, type CheckFlagEnablement, type CheckPreparation } from "../../check/check.ts";
+import type { HandoffProviderIdentity } from "../../check/handoff-provider-identity.ts";
 export type TrustedDataParser = (this: void, ...parameters: never[]) => unknown;
 export interface CheckAuthoringData extends Readonly<Record<string, unknown>> {
     readonly checkId: string;
@@ -8,18 +9,22 @@ export interface CheckAuthoringData extends Readonly<Record<string, unknown>> {
 export interface ParsedCheckFields {
     readonly definition: CheckDescriptor | null;
     readonly enabledByFlags: CheckFlagEnablement | null;
-    readonly execution: CheckExecution | null;
+    readonly execute: NonNullable<Check["execute"]> | null;
+    readonly handoff: HandoffProviderIdentity | null;
     readonly options: object | null;
     readonly parseData: TrustedDataParser | null;
-    readonly preflight: CheckPreflight | null;
-    readonly visibility: CheckVisibility | null;
+    readonly prepare: CheckPreparation | null;
+    readonly omitQuietPassedRow: boolean | null;
 }
 export interface ParsedCheckFieldPrelude {
     readonly enabledByFlags: CheckFlagEnablement | null;
-    readonly execution: CheckExecution | null;
+    readonly execute: NonNullable<Check["execute"]> | null;
+    readonly handoff: HandoffProviderIdentity | null;
     readonly parseData: TrustedDataParser | null;
-    readonly preflight: CheckPreflight | null;
+    readonly prepare: CheckPreparation | null;
 }
 export declare function parseCheckAuthoringData(value: unknown): CheckAuthoringData | undefined;
-export declare function parseCheckFieldPrelude(data: CheckAuthoringData): ParsedCheckFieldPrelude | undefined;
+export declare function parseCheckFieldPrelude(data: CheckAuthoringData, handoffProviderIdentity: HandoffProviderIdentity | undefined): ParsedCheckFieldPrelude | undefined;
 export declare function parseCheckFields(data: CheckAuthoringData, prelude: ParsedCheckFieldPrelude): ParsedCheckFields | undefined;
+/** Parses one closed flag-enablement field without validating its Project flag references. */
+export declare function parseFlagEnablementControl(value: unknown): CheckFlagEnablement | undefined;

package/types/project-definition/check-tree/flag-conditions.d.ts

@@ -0,0 +1,5 @@
+import type { CheckFlagCondition } from "../../check/check.ts";
+/** Parses and snapshots one bounded recursive flag condition while retaining child order and multiplicity. */
+export declare function parseFlagCondition(value: unknown): CheckFlagCondition | undefined;
+/** Checks that a closed record has no author-supplied keys outside this grammar fragment. */
+export declare function hasOnlyKeys(value: Readonly<Record<string, unknown>>, keys: readonly string[]): boolean;

package/types/project-definition/check-tree/resolution.d.ts

@@ -1,5 +1,6 @@
 import type { CheckDescriptor } from "../../check/descriptor.ts";
-import type { CheckExecution, CheckFlagEnablement, CheckPreflight, CheckVisibility } from "../../check/check.ts";
+import type { Check, CheckPreparation, CheckFlagEnablement } from "../../check/check.ts";
+import type { HandoffProviderIdentity } from "../../check/handoff-provider-identity.ts";
 import { type MeaninglessCheckWarning, type ParsedCheckTree } from "./authoring.ts";
 import { type ResourceUnitMapping } from "../resource-unit-mapping.ts";
 export type { Check, InheritableCheckCollection } from "../../check/check.ts";
@@ -8,14 +9,15 @@ export interface ResolvedCheckTreeLeaf {
     readonly definition: CheckDescriptor;
     readonly dependsOn: readonly string[];
     readonly enabledByFlags?: CheckFlagEnablement;
-    readonly execution: CheckExecution;
+    readonly execute: NonNullable<Check["execute"]>;
+    readonly handoff?: HandoffProviderIdentity;
     readonly maxParallel: number;
     readonly mutex: readonly string[];
     readonly observes: readonly string[];
     readonly options: object;
-    readonly preflight?: CheckPreflight;
+    readonly prepare?: CheckPreparation;
     readonly resourceClaims: ResourceUnitMapping;
-    readonly visibility: CheckVisibility;
+    readonly omitQuietPassedRow: boolean;
 }
 export interface ResolvedCheckTree {
     readonly leaves: readonly ResolvedCheckTreeLeaf[];

package/types/project-definition/declarative-snapshot.d.ts

@@ -1,7 +1,10 @@
 import type { DeclarativeProjectSnapshot, NormalizedCheck, ProjectDefinition } from "./project-definition.ts";
+import type { NormalizedProjectChangesConfiguration } from "./project-changes.ts";
 /**
  * Produces the immutable, callback-free Definition identity consumed by fingerprinting.
  */
-export declare function createDeclarativeProjectSnapshot(definition: ProjectDefinition, checks: readonly NormalizedCheck[]): DeclarativeProjectSnapshot;
+export declare function createDeclarativeProjectSnapshot(definition: Omit<ProjectDefinition, "changes"> & {
+    readonly changes?: NormalizedProjectChangesConfiguration;
+}, checks: readonly NormalizedCheck[]): DeclarativeProjectSnapshot;
 /** Generates the stable SHA-256 fingerprint for one declarative Definition snapshot. */
 export declare function createDeclarativeFingerprint(snapshot: DeclarativeProjectSnapshot): string;

package/types/project-definition/project-changes.d.ts

@@ -0,0 +1,30 @@
+/** Project 自有的 Git comparison，用于为一次 Run 推导 change flags。 */
+export interface ProjectChangeSource {
+    /** 作为 comparison base 的 Git revision。 */
+    readonly compareWith: string;
+}
+/** 一个 change flag 的 project-root-relative、exclude-first glob region。 */
+export interface ProjectChangeFlagRegion {
+    /** 可省略的排除 glob；省略等同空数组，显式 undefined 不是合法数组。 */
+    readonly exclude?: readonly string[];
+    readonly include: readonly string[];
+}
+/** 由 Project Definition 拥有的静态 change preparation 配置。 */
+export interface ProjectChangesConfiguration {
+    readonly source: ProjectChangeSource;
+    /** 至少一个非空 author ID 到其匹配 region 的映射。 */
+    readonly flags: Readonly<Record<string, ProjectChangeFlagRegion>>;
+}
+/** Definition 已验证、补齐并冻结的 region；Run 不再解释 authoring defaults。 */
+export interface NormalizedProjectChangeFlagRegion extends ProjectChangeFlagRegion {
+    readonly exclude: readonly string[];
+}
+/** 仅供 Definition snapshot 与 Run 消费的完整 change 配置。 */
+export interface NormalizedProjectChangesConfiguration extends ProjectChangesConfiguration {
+    readonly flags: Readonly<Record<string, NormalizedProjectChangeFlagRegion>>;
+}
+/**
+ * 解析并冻结 change preparation 的 closed Definition grammar。
+ * Runtime Git acquisition 与 region matching 有各自的 Run owner，不在此边界执行。
+ */
+export declare function parseProjectChangesConfiguration(value: unknown): NormalizedProjectChangesConfiguration | undefined;

package/types/project-definition/project-definition.d.ts

@@ -1,7 +1,9 @@
 import type { MeaninglessCheckWarning } from "./check-tree/authoring.ts";
 import type { CheckDescriptor } from "../check/descriptor.ts";
-import type { Check, CheckExecution, CheckFlagEnablement, CheckPreflight, CheckResourceClaims, CheckVisibility } from "../check/check.ts";
+import type { Check, CheckPreparation, CheckResourceClaims, CheckFlagEnablement } from "../check/check.ts";
+import type { HandoffProviderIdentity } from "../check/handoff-provider-identity.ts";
 import type { ProgressRenderingOutput, ResolvedProgressRenderingOutput } from "./progress-rendering-output.ts";
+import { type NormalizedProjectChangesConfiguration, type ProjectChangesConfiguration } from "./project-changes.ts";
 export { createDeclarativeFingerprint } from "./declarative-snapshot.ts";
 /** 一次 Project Run 的明确输出配置。 */
 export interface ProjectOutputs {
@@ -37,8 +39,8 @@ export interface DeclarativeProjectOutputs extends Omit<ProjectOutputs, "progres
         readonly textPreviewCodePointLimit: number;
     }>;
 }
-export type { AdmissionPolicy, AdmissionPolicyContext, AdmissionPolicyMeasurement, AdmissionProposal, AdmissionCatalog, AdmissionGraph, AdmissionGraphInput, AdmissionInspection, AdmissionNonSelectableTask, AdmissionRejectionReason, AdmissionScopeLifecycle, AdmissionSelectionRejectionReason, AdmissionSelectionValidation, AdmissionSelectionValidationRejectionReason, AdmissionSettlementOutcome, AdmissionSettledTask, AdmissionState, AdmissionTransitionResult, CustomAdmissionPreparationContext, CustomAdmissionStrategy, PreparedCustomAdmissionStrategy, SchedulerDecisionMeasurementCumulative, SchedulerGraphSnapshot, SchedulerMeasurementActionObservation, SchedulerMeasurementActionObservationInterval, SchedulerMeasurementAdmission, SchedulerMeasurementContext, SchedulerMeasurementEffect, SchedulerMeasurementHook, SchedulerMeasurementIntervalContribution, SchedulerMeasurementPeakCounts, SchedulerMeasurementTiming, SchedulerMeasurementTimingFacts, SchedulerMeasurementTimingUnavailableReason, SchedulerPolicy, SchedulerRawMeasurement } from "./scheduler-policy.ts";
-import type { AdmissionPolicy, CustomAdmissionStrategy, CustomAdmissionPreparationContext, DeclarativeSchedulerPolicy, PreparedCustomAdmissionStrategy, SchedulerPolicy } from "./scheduler-policy.ts";
+export type { AdmissionPolicy, AdmissionPolicyContext, AdmissionPolicyMeasurement, AdmissionProposal, AdmissionCatalog, AdmissionGraph, AdmissionGraphInput, AdmissionInspection, AdmissionNonSelectableTask, AdmissionRejectionReason, AdmissionScopeLifecycle, AdmissionSelectionRejectionReason, AdmissionSelectionValidation, AdmissionSelectionValidationRejectionReason, AdmissionSettlementOutcome, AdmissionSettledTask, AdmissionState, AdmissionTransitionResult, CustomAdmissionPreparationContext, CustomAdmissionStrategy, PreparedCustomAdmissionStrategy, SchedulerDecisionMeasurementCumulative, SchedulerGraphSnapshot, SchedulerMeasurementActionObservation, SchedulerMeasurementActionObservationInterval, SchedulerMeasurementAdmission, SchedulerMeasurementContext, SchedulerMeasurementEffect, SchedulerTerminalEffect, SchedulerMeasurementIntervalContribution, SchedulerMeasurementPeakCounts, SchedulerMeasurementTiming, SchedulerMeasurementTimingFacts, SchedulerMeasurementTimingUnavailableReason, SchedulerPolicy, SchedulerRawMeasurement } from "./scheduler-policy.ts";
+import type { DeclarativeSchedulerPolicy, SchedulerPolicy } from "./scheduler-policy.ts";
 /**
  * `defineConfig(...)` 形成的可重复运行项目定义：声明检查内容、调度方式与默认输出。
  *
@@ -48,12 +50,15 @@ import type { AdmissionPolicy, CustomAdmissionStrategy, CustomAdmissionPreparati
 export interface ProjectDefinition {
     readonly apiVersion: "1";
     readonly checks: readonly Check[];
+    /** 可选的静态 Git comparison 与本次 Run 的 change-flag regions。 */
+    readonly changes?: ProjectChangesConfiguration;
     readonly outputs: ProjectOutputs;
     readonly scheduler: SchedulerPolicy;
 }
 type ProjectDefinitionInput = Readonly<{
     apiVersion?: "1";
     checks?: readonly Check[];
+    changes?: ProjectChangesConfiguration;
     outputs?: Partial<{
         machinePublication: Partial<ProjectOutputs["machinePublication"]>;
         progressRendering: Partial<ProjectOutputs["progressRendering"]>;
@@ -79,55 +84,35 @@ export interface NormalizedCheckDeclaration {
     readonly admissionPriority: number;
     readonly definition: CheckDescriptor;
     readonly dependsOn: readonly string[];
+    /** Definition 已验证、snapshot 并冻结的单一 recursive flag-condition control。 */
     readonly enabledByFlags?: CheckFlagEnablement;
     readonly maxParallel: number;
     readonly mutex: readonly string[];
     readonly observes: readonly string[];
     readonly options: object;
     readonly resourceClaims: CheckResourceClaims;
-    readonly visibility: CheckVisibility;
+    readonly omitQuietPassedRow: boolean;
 }
 export interface NormalizedCheck extends NormalizedCheckDeclaration {
-    readonly execution: CheckExecution;
-    readonly preflight?: CheckPreflight;
+    readonly execute: NonNullable<Check["execute"]>;
+    readonly handoff?: HandoffProviderIdentity;
+    readonly prepare?: CheckPreparation;
 }
 export interface DeclarativeProjectSnapshot {
     readonly apiVersion: "1";
     readonly checks: readonly NormalizedCheckDeclaration[];
+    readonly changes?: NormalizedProjectChangesConfiguration;
     readonly outputs: DeclarativeProjectOutputs;
     readonly scheduler: DeclarativeSchedulerPolicy;
 }
 export interface NormalizedProjectDefinition {
     readonly checks: readonly NormalizedCheck[];
+    readonly changes?: NormalizedProjectChangesConfiguration;
     readonly declarative: DeclarativeProjectSnapshot;
     readonly definitionWarnings: readonly DefinitionWarning[];
     /** Runtime scheduler policy；custom callback 保留在此处。 */
     readonly scheduler: SchedulerPolicy;
 }
-type ExactAdmissionPolicy<T extends AdmissionPolicy> = T extends Readonly<{
-    readonly kind: "static";
-}> ? T & Record<Exclude<keyof T, "kind">, never> : T extends Readonly<{
-    readonly kind: "custom";
-}> ? T & Record<Exclude<keyof T, "kind" | "strategy">, never> & Readonly<{
-    readonly strategy: ExactCustomAdmissionStrategy<T["strategy"]>;
-}> : never;
-type ExactCustomAdmissionStrategy<T extends CustomAdmissionStrategy> = T extends Readonly<{
-    readonly kind: "simple";
-}> ? T & Record<Exclude<keyof T, "kind" | "decide">, never> : T extends Readonly<{
-    readonly kind: "prepared";
-}> ? T & Record<Exclude<keyof T, "kind" | "prepare">, never> & Readonly<{
-    readonly prepare: ExactCustomPreparation<T["prepare"]>;
-}> : never;
-type ExactCustomPreparation<T> = T extends (this: void, context: CustomAdmissionPreparationContext) => infer Result ? (this: void, context: CustomAdmissionPreparationContext) => ExactCustomPreparationResult<Result> : never;
-type ExactCustomPreparationResult<T> = T extends Promise<unknown> ? Promise<ExactPreparedCustomAdmissionStrategy<Awaited<T>>> : ExactPreparedCustomAdmissionStrategy<T>;
-type ExactPreparedCustomAdmissionStrategy<T> = T extends PreparedCustomAdmissionStrategy ? T & Record<Exclude<keyof T, "decide" | "complete">, never> : never;
-/**
- * 保留 closed admission policy literal 的 TypeScript inference，不创建额外运行语义。
- *
- * @remarks inline policy 与此 helper 的结果完全等价。custom simple `decide` 同步运行；prepared
- * strategy 为每个 graph-ready Run 解析独立 closure，调用方负责其 trusted host callback 的可重入性。
- */
-export declare function defineAdmissionPolicy<const T extends AdmissionPolicy>(policy: ExactAdmissionPolicy<T>): T;
 /** 使用 Product 默认输出创建普通 Project Definition。 */
 export declare function defineConfig<const T extends ProjectDefinitionInput>(value: T & Record<Exclude<keyof T, keyof ProjectDefinitionInput>, never>): ProjectDefinition;
 export declare function normalizeProjectDefinition(definition: ProjectDefinition): NormalizedProjectDefinition;

package/types/project-definition/scheduler-policy.d.ts

@@ -196,7 +196,7 @@ export interface PreparedCustomAdmissionStrategy {
     /** Scheduler 每轮同步调用；不得返回 Promise 或 thenable。 */
     readonly decide: (this: void, context: AdmissionPolicyContext) => AdmissionProposal;
     /** Scheduler 的 generic Hooks 完成后，才以 sealed terminal context 调用一次。 */
-    readonly complete?: (this: void, context: SchedulerMeasurementContext) => void | Promise<void>;
+    readonly terminalEffect?: (this: void, context: SchedulerMeasurementContext) => void | Promise<void>;
 }
 /** custom 的 closed authoring grammar。 */
 export type CustomAdmissionStrategy = Readonly<{
@@ -470,7 +470,7 @@ export interface SchedulerMeasurementContext {
     readonly rawMeasurement: SchedulerRawMeasurement;
 }
 /** 一次 terminal Scheduler measurement 的 caller-owned sync/async consumer。 */
-export type SchedulerMeasurementHook = ((this: void, context: SchedulerMeasurementContext) => void) | ((this: void, context: SchedulerMeasurementContext) => Promise<void>);
+export type SchedulerTerminalEffect = ((this: void, context: SchedulerMeasurementContext) => void) | ((this: void, context: SchedulerMeasurementContext) => Promise<void>);
 /** 定义级的 Scheduler 预算、admission policy 与终态 measurement consumer。 */
 export interface SchedulerPolicy {
     /** normalized static or custom admission policy。 */
@@ -478,7 +478,7 @@ export interface SchedulerPolicy {
     /** 同时 running 的 root Check 上限。 */
     readonly maxParallel: number;
     /** terminal measurement 的 caller-owned consumers，按配置顺序调用。 */
-    readonly measurementHooks: readonly SchedulerMeasurementHook[];
+    readonly terminalEffects: readonly SchedulerTerminalEffect[];
     /** 本次 Definition 中可由 Check 原子占用的 named resource 总 units。 */
     readonly resourceCapacities: Readonly<Record<string, number>>;
 }

package/types/project-run/admission-strategy-provider/prepared-admission-strategy.d.ts

@@ -9,8 +9,8 @@ export type PreparedAdmissionStrategyCompletion = Readonly<{
     readonly kind: "internal";
     readonly complete: (context: InternalAdmissionStrategyCompleteContext) => Promise<void>;
 }> | Readonly<{
-    readonly kind: "measurement-hook";
-    readonly complete: (context: SchedulerMeasurementContext) => void | Promise<void>;
+    readonly kind: "terminal-effect";
+    readonly terminalEffect: (context: SchedulerMeasurementContext) => void | Promise<void>;
 }>;
 /** The invocation-scoped handoff from an admission provider to Scheduler and terminal delivery. */
 export interface PreparedAdmissionStrategy {

package/types/project-run/aggregation.d.ts

@@ -1,7 +1,9 @@
-import type { RunControlValidationResult } from "./controls/validation-result.ts";
-import type { CheckAggregate, CheckAggregation } from "./controls/contract.ts";
 import type { CoreSnapshot } from "../check-settlement/facts.ts";
-/** Validates that aggregation selects only normalized executable Check IDs. */
-export declare function validateCheckAggregationSelection(aggregation: CheckAggregation | undefined, checkIds: readonly string[]): RunControlValidationResult<CheckAggregation | undefined>;
-/** Derives one explicit consumer-selected aggregate from settled Check statuses only. */
-export declare function aggregateCheckOutcomes(snapshot: CoreSnapshot, aggregation: CheckAggregation, effectiveCheckIds: readonly string[]): CheckAggregate;
+import type { CheckAggregate, CheckAggregation } from "./controls/contract.ts";
+/** Identifies a callback failure so the invocation boundary can close outputs before rethrowing it. */
+export declare class CheckAggregationFailure extends Error {
+    readonly originalError: Error;
+    constructor(originalError: Error);
+}
+/** Builds the canonical ordered, read-only effective Check list and derives its invocation aggregate. */
+export declare function aggregateEffectiveChecks(snapshot: CoreSnapshot, effectiveCheckIds: readonly string[], aggregation: CheckAggregation | undefined): CheckAggregate;

package/types/project-run/changes/git.d.ts

@@ -0,0 +1,14 @@
+import type { ProjectChanges } from "../../check/check.ts";
+import type { NormalizedProjectChangesConfiguration } from "../../project-definition/project-changes.ts";
+export declare const CHANGE_FLAG_PREFIX = "vibe-check:change:";
+export declare const GIT_CHANGES_UNAVAILABLE_CODE = "git-changes-unavailable";
+export type PreparedProjectChanges = Readonly<{
+    readonly effectiveFlags: readonly string[];
+    readonly projectChanges: ProjectChanges;
+}>;
+/** Prepares one configured Git change snapshot before Run flag selection. */
+export declare function prepareProjectChanges(input: Readonly<{
+    readonly callerFlags: readonly string[];
+    readonly changes: NormalizedProjectChangesConfiguration;
+    readonly projectRoot: string;
+}>): PreparedProjectChanges;

package/types/project-run/check-execution/admitted-check-execution.d.ts

@@ -0,0 +1,18 @@
+/** Handles one admitted Check's preparation boundary and ready callback handoff. */
+import type { CheckProjectContext } from "../../check/check.ts";
+import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
+import type { ResolvedInvocationPaths } from "../invocation/paths.ts";
+import { type CheckExecutionState } from "./execution-settlement.ts";
+export type CheckExecutionClock = Readonly<{
+    now(): number;
+}>;
+export type AdmittedCheckExecutionInput = CheckExecutionState & Readonly<{
+    readonly check: NormalizedCheck;
+    readonly clock: CheckExecutionClock;
+    readonly onAdmittedCheck: ((check: NormalizedCheck) => void) | undefined;
+    readonly invocationId: string;
+    readonly paths: ResolvedInvocationPaths | undefined;
+    readonly project: CheckProjectContext;
+    readonly signal: AbortSignal;
+}>;
+export declare function executeAdmittedCheck(input: AdmittedCheckExecutionInput): Promise<boolean>;

package/types/project-run/check-execution/dependencies.d.ts

@@ -1,9 +1,12 @@
 import type { CheckDependencies } from "../../check/check.ts";
 import type { CoreCheckSession } from "../../check-settlement/session.ts";
 import { type DiagnosticLogger } from "../diagnostic-logging/logger.ts";
+import type { ParsedCheckTerminalHandoff } from "./terminal-result.ts";
 export declare function createCheckDependencies(input: Readonly<{
     readonly checkId: string;
+    readonly directDependsOnCheckIds: readonly string[];
     readonly diagnosticLogger: DiagnosticLogger | undefined;
     readonly directRelationCheckIds: readonly string[];
+    readonly handoffsByCheckId: ReadonlyMap<string, ParsedCheckTerminalHandoff>;
     readonly session: CoreCheckSession;
 }>): CheckDependencies;

package/types/project-run/check-execution/execution-finalization.d.ts

@@ -18,7 +18,7 @@ export declare function closeCancelledExecution(input: Readonly<{
     readonly state: CheckExecutionState;
     readonly terminalSchedulerMeasurement?: SchedulerMeasurementContext;
 }>): ResolvedCheckExecution;
-export declare function checkIdentity(check: Pick<NormalizedCheck, "definition" | "visibility">): CheckIdentity;
+export declare function checkIdentity(check: Pick<NormalizedCheck, "definition" | "omitQuietPassedRow">): CheckIdentity;
 export declare function trustedFailure(error: unknown): CheckExecutionInvariantFailure;
 /** Closes one Scheduler-blocked Check before a terminal observer may start. */
 export declare function settleBlockedDependent(input: Readonly<{

package/types/project-run/check-execution/execution-settlement.d.ts

@@ -1,21 +1,24 @@
-import type { CheckMessage, CheckOutcome, CheckVisibility } from "../../check/check.ts";
+import type { CheckMessage, CheckOutcome } from "../../check/check.ts";
+import type { HandoffProviderIdentity } from "../../check/handoff-provider-identity.ts";
 import type { CoreCheckSession } from "../../check-settlement/session.ts";
 import { type DiagnosticLogger } from "../diagnostic-logging/logger.ts";
+import { type ParsedCheckTerminalHandoff } from "./terminal-result.ts";
 import type { CheckExecutionLifecycle } from "./lifecycle.ts";
 import type { executeCheckCallback } from "./callback.ts";
 export type CheckIdentity = Readonly<{
     readonly checkId: string;
     readonly displayName: string;
-    readonly visibility: CheckVisibility;
+    readonly omitQuietPassedRow: boolean;
 }>;
 export interface SettledCheckFacts {
     readonly durationMs: number | null;
     readonly messages: readonly CheckMessage[];
 }
 export type CheckExecutionSettlementState = Readonly<{
-    readonly session: CoreCheckSession;
     readonly diagnosticLogger: DiagnosticLogger | undefined;
+    readonly handoffsByCheckId: Map<string, ParsedCheckTerminalHandoff>;
     readonly lifecycle: CheckExecutionLifecycle | undefined;
+    readonly session: CoreCheckSession;
     readonly settledFactsByCheckId: Map<string, SettledCheckFacts>;
 }>;
 /** Mutable execution session state shared by execution and terminal finalization. */
@@ -23,22 +26,27 @@ export type CheckExecutionState = CheckExecutionSettlementState;
 export declare class CheckExecutionInvariantFailure extends Error {
     constructor(message: string);
 }
-export declare function settleCallback(input: Readonly<{
+type SettleCallbackInput = Readonly<{
     readonly callback: Awaited<ReturnType<typeof executeCheckCallback>>;
     readonly checkId: string;
     readonly diagnosticLogger: DiagnosticLogger | undefined;
-    readonly preflightMessages: readonly CheckMessage[];
+    readonly handoff: HandoffProviderIdentity | undefined;
+    readonly preparationMessages: readonly CheckMessage[];
     readonly scope: ReturnType<CoreCheckSession["openCheckScope"]>;
-}>): Readonly<{
+    readonly state: CheckExecutionSettlementState;
+}>;
+type SettledCallback = Readonly<{
     readonly messages: readonly CheckMessage[];
     readonly outcome: CheckOutcome;
 }>;
+export declare function settleCallback(input: SettleCallbackInput): SettledCallback;
 /** Records one terminal Check lifecycle fact after its owning Core scope has closed. */
 export declare function recordSettledCheck(input: Readonly<{
     readonly check: CheckIdentity;
     readonly durationMs: number | null;
     readonly messages: readonly CheckMessage[];
     readonly outcome: CheckOutcome;
-    readonly phase: "control" | "dependency" | "execution" | "preflight";
+    readonly phase: "control" | "dependency" | "execution" | "preparation";
     readonly state: CheckExecutionSettlementState;
 }>): void;
+export {};

package/types/project-run/check-execution/flag-controls.d.ts

@@ -1,7 +1,7 @@
 import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
 import { type DiagnosticLogger } from "../diagnostic-logging/logger.ts";
 export declare const FLAG_CONDITION_NOT_MATCHED_CODE = "flag-condition-not-matched";
-type FlagControlledCheck = Pick<NormalizedCheck, "definition" | "visibility">;
+type FlagControlledCheck = Pick<NormalizedCheck, "definition" | "omitQuietPassedRow">;
 type FlagControlOutcome = Readonly<{
     readonly status: "not-applicable";
     readonly reason: Readonly<{

package/types/project-run/check-execution/lifecycle.d.ts

@@ -1,20 +1,24 @@
-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";
-/** Private Run handoff for Check lifecycle presentation and accounting. */
+/** Private invocation-wide barrier that is independent from per-Check lifecycle facts. */
+export type InvocationLifecycle = Readonly<{
+    /** Fires once after Product accepts every flag-control settlement and before Scheduler work. */
+    readonly selectionSettled: () => void;
+}>;
+/** Private per-Check lifecycle presentation and accounting channel. */
 export type CheckExecutionLifecycle = Readonly<{
-    /** Fires after the invocation-wide flag-control phase and before Scheduler execution starts. */
-    readonly flagControlCompleted: () => void;
     readonly started: (fact: CheckStartedFact) => void;
     readonly settled: (fact: CheckSettledFact) => void;
 }>;
 export type CheckStartedFact = Readonly<{
     checkId: string;
     displayName: string;
+    omitQuietPassedRow: boolean;
 }>;
 export type CheckSettledFact = CheckStartedFact & Readonly<{
     durationMs: number | null;
     messages: readonly CheckMessage[];
     records: readonly CoreRecord[];
     outcome: CheckOutcome;
-    visibility: CheckVisibility;
+    omitQuietPassedRow: boolean;
 }>;

package/types/project-run/check-execution/{preflight-result.d.ts → preparation-result.d.ts}

@@ -1,5 +1,5 @@
 import type { CheckMessage } from "../../check/check.ts";
-export type ParsedCheckPreflightResult = Readonly<{
+export type ParsedCheckPreparationResult = Readonly<{
     readonly status: "success";
     readonly preparedOptions: unknown;
     readonly messages: readonly CheckMessage[];
@@ -19,5 +19,5 @@ export type ParsedCheckPreflightResult = Readonly<{
     };
     readonly messages: readonly CheckMessage[];
 }>;
-/** Parses the closed result vocabulary returned by one trusted Check preflight. */
-export declare function parseCheckPreflightResult(value: unknown): ParsedCheckPreflightResult | undefined;
+/** Parses the closed result vocabulary returned by one trusted Check preparation. */
+export declare function parseCheckPreparationResult(value: unknown): ParsedCheckPreparationResult | undefined;

package/types/project-run/check-execution/{preflight.d.ts → preparation.d.ts}

@@ -1,28 +1,29 @@
-import type { CheckMessage, CheckOutcome } from "../../check/check.ts";
+import type { CheckMessage, CheckOutcome, CheckProjectContext } from "../../check/check.ts";
 import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
 import { type DiagnosticLogger } from "../diagnostic-logging/logger.ts";
-export type PreparedCheck = Omit<NormalizedCheck, "options" | "preflight"> & Readonly<{
+export type PreparedCheck = Omit<NormalizedCheck, "options" | "prepare"> & Readonly<{
     readonly options: object;
-    readonly preflightMessages: readonly CheckMessage[];
+    readonly preparationMessages: readonly CheckMessage[];
 }>;
-type BlockedCheck = Pick<NormalizedCheck, "definition" | "visibility"> & Readonly<{
-    readonly preflightMessages: readonly CheckMessage[];
+type BlockedCheck = Pick<NormalizedCheck, "definition" | "omitQuietPassedRow"> & Readonly<{
+    readonly preparationMessages: readonly CheckMessage[];
 }>;
-export type ReadyCheckPreflightResolution = Readonly<{
+export type ReadyCheckPreparationResolution = Readonly<{
     readonly kind: "ready";
     readonly check: PreparedCheck;
 }>;
-export type BlockedCheckPreflightResolution = Readonly<{
+export type BlockedCheckPreparationResolution = Readonly<{
     readonly kind: "blocked";
     readonly check: BlockedCheck;
     readonly outcome: CheckOutcome;
 }>;
-export type CheckPreflightResolution = ReadyCheckPreflightResolution | BlockedCheckPreflightResolution;
+export type CheckPreparationResolution = ReadyCheckPreparationResolution | BlockedCheckPreparationResolution;
 type PrepareCheckInput = Readonly<{
     readonly check: NormalizedCheck;
     readonly diagnosticLogger: DiagnosticLogger | undefined;
+    readonly project: CheckProjectContext;
     readonly signal: AbortSignal | undefined;
 }>;
 /** Resolves one Check's task-local preparation after Scheduler admission. */
-export declare function prepareCheck(input: PrepareCheckInput): Promise<CheckPreflightResolution>;
+export declare function prepareCheck(input: PrepareCheckInput): Promise<CheckPreparationResolution>;
 export {};

package/types/project-run/check-execution/ready-check-execution.d.ts

@@ -0,0 +1,18 @@
+/** Executes and settles a Check after its task-local preparation has admitted it. */
+import type { CheckProjectContext } from "../../check/check.ts";
+import type { NormalizedCheck } from "../../project-definition/project-definition.ts";
+import { type ResolvedInvocationPaths } from "../invocation/paths.ts";
+import { type CheckExecutionState } from "./execution-settlement.ts";
+import type { ReadyCheckPreparationResolution } from "./preparation.ts";
+export type ReadyCheckExecutionInput = CheckExecutionState & Readonly<{
+    readonly check: NormalizedCheck;
+    readonly clock: Readonly<{
+        now(): number;
+    }>;
+    readonly invocationId: string;
+    readonly paths: ResolvedInvocationPaths | undefined;
+    readonly prepare: ReadyCheckPreparationResolution;
+    readonly project: CheckProjectContext;
+    readonly signal: AbortSignal;
+}>;
+export declare function executeReadyCheck(input: ReadyCheckExecutionInput): Promise<boolean>;

package/types/project-run/check-execution/resolved-checks.d.ts

@@ -1,17 +1,16 @@
 import type { CheckProjectContext } from "../../check/check.ts";
-import type { NormalizedCheck, SchedulerMeasurementHook } from "../../project-definition/project-definition.ts";
+import type { NormalizedCheck, SchedulerTerminalEffect } from "../../project-definition/project-definition.ts";
 import type { ResourceUnitMapping } from "../../project-definition/resource-unit-mapping.ts";
-import { type DiagnosticLogger } from "../diagnostic-logging/logger.ts";
+import type { DiagnosticLogger } from "../diagnostic-logging/logger.ts";
 import type { AdmissionSelectionPolicy } from "../task-scheduler/admission-selection-policy.ts";
 import type { SchedulerPerformanceDiagnosticsInput } from "../task-scheduler/measurement/diagnostics.ts";
-import { type ResolvedInvocationPaths } from "../invocation/paths.ts";
-import type { CheckExecutionLifecycle } from "./lifecycle.ts";
+import type { ResolvedInvocationPaths } from "../invocation/paths.ts";
+import type { CheckExecutionLifecycle, InvocationLifecycle } from "./lifecycle.ts";
+import type { CheckExecutionClock } from "./admitted-check-execution.ts";
 import type { ResolvedCheckExecution } from "./resolved-execution-result.ts";
 /** Package-private monotonic clock seam for execution accounting. */
-export type CheckExecutionClock = Readonly<{
-    now(): number;
-}>;
-type ResolvedCheckExecutionInput = Readonly<{
+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[];
@@ -30,10 +29,11 @@ type ResolvedCheckExecutionInput = Readonly<{
     readonly schedulerDiagnosticLogger?: DiagnosticLogger;
     /** Explicit enabled-only diagnostics handoff from the invocation output owner. */
     readonly schedulerPerformanceDiagnostics?: SchedulerPerformanceDiagnosticsInput;
-    readonly schedulerMeasurementHooks?: readonly SchedulerMeasurementHook[];
-    readonly onSchedulerMeasurementHookFailure?: () => void;
-    readonly onSchedulerMeasurementHooksSettled?: () => void;
-    readonly lifecycle?: CheckExecutionLifecycle;
+    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;
 }>;
@@ -42,4 +42,3 @@ type ResolvedCheckExecutionInput = Readonly<{
  * Task per Check. Graph validation happens before Core scopes or callbacks.
  */
 export declare function executeResolvedChecks(input: ResolvedCheckExecutionInput): Promise<ResolvedCheckExecution>;
-export {};

package/types/project-run/check-execution/scheduled-check-run.d.ts

@@ -0,0 +1,10 @@
+/** Maps normalized Checks into the Scheduler's opaque Task execute contract. */
+import { runTaskGraph } from "../task-scheduler/scheduler.ts";
+import { type CheckExecutionState } from "./execution-settlement.ts";
+import type { FlagControlSettlement } from "./flag-controls.ts";
+import type { ResolvedCheckExecutionInput } from "./resolved-checks.ts";
+export declare function runScheduledChecks(input: Readonly<{
+    readonly execution: ResolvedCheckExecutionInput;
+    readonly flagControlSettlements: readonly FlagControlSettlement[];
+    readonly state: CheckExecutionState;
+}>): Promise<Awaited<ReturnType<typeof runTaskGraph<boolean>>>>;

package/types/project-run/check-execution/terminal-result.d.ts

@@ -1,13 +1,20 @@
 import type { CheckMessage } from "../../check/check.ts";
+import type { HandoffProviderIdentity } from "../../check/handoff-provider-identity.ts";
 /**
  * A terminal callback result split into the Core-owned four-state result and
  * detached presentation-only messages. The caller must still pass `result` to
  * Core; this adapter never validates outcome data or reasons.
  */
 export interface ParsedCheckTerminalResult {
+    readonly handoff: ParsedCheckTerminalHandoff | undefined;
     readonly messages: readonly CheckMessage[];
     readonly result: StrippedTerminalResult;
 }
+/** A validated reference held only until its owning Core terminal settlement accepts it. */
+export interface ParsedCheckTerminalHandoff {
+    readonly identity: HandoffProviderIdentity;
+    readonly value: object;
+}
 type StrippedTerminalResult = Readonly<{
     readonly status: "passed" | "failed";
     readonly data: unknown;
@@ -23,5 +30,10 @@ type StrippedTerminalResult = Readonly<{
  * closed author result. Any malformed attachment rejects the whole value so a
  * valid prefix can never escape into lifecycle or Run result state.
  */
-export declare function parseCheckTerminalResult(value: unknown): ParsedCheckTerminalResult | undefined;
+export declare function parseCheckTerminalResult(value: unknown, handoffIdentity: HandoffProviderIdentity | undefined): ParsedCheckTerminalResult | undefined;
+/**
+ * A declared provider result can contain an invocation-private reference. Diagnostics
+ * retain only its parsed terminal result, and represent malformed values as null.
+ */
+export declare function diagnosticCallbackResult(value: unknown, handoffIdentity: HandoffProviderIdentity | undefined): unknown;
 export {};

package/types/project-run/completion/completion.d.ts

@@ -4,7 +4,7 @@ import type { Invocation } from "../invocation/run.ts";
 import type { CoreSnapshot } from "../../check-settlement/facts.ts";
 /** Settled Check facts consumed by completion and output publication. */
 export type CoreExecution = Readonly<{
-    readonly aggregate: CheckAggregate | null;
+    readonly aggregate: CheckAggregate;
     readonly checkDurations: readonly CheckDuration[];
     readonly checkMessages: readonly CheckRunMessage[];
     readonly snapshot: CoreSnapshot;
@@ -12,3 +12,5 @@ export type CoreExecution = Readonly<{
 export declare function completeInvocation(invocation: Invocation, core: CoreExecution): NonConfigurationRunResult;
 /** Closes diagnostic logging and applies final output priority to a non-configuration candidate. */
 export declare function finalizeInvocation(invocation: Invocation, candidate: NonConfigurationRunResult): NonConfigurationRunResult;
+/** Closes invocation-owned writers after aggregation rejects without fabricating a terminal Run result. */
+export declare function closeAggregationFailure(invocation: Invocation): void;