@zxyycom/vibe-check 0.0.1 → 0.0.2

package/src/check-settlement/fact-validation.ts

@@ -2,7 +2,13 @@ import { canonicalizeJsonObject } from "../data-boundary/canonical-data.ts";
 import type { CheckOutcome } from "../check/check.ts";
 import { validateCheckDescriptor } from "../check/descriptor-validation.ts";
 import type { CoreCheck, CoreRecord, CoreSnapshot } from "./facts.ts";
-import { snapshotClosedArray, snapshotClosedRecord } from "../data-boundary/closed-values.ts";
+import {
+  hasExactPlainRecordKeys,
+  hasRequiredAndOptionalRecordKeys,
+  snapshotClosedArray,
+  snapshotClosedRecord
+} from "../data-boundary/closed-values.ts";
+import { isClosedCheckReason } from "./reason-shape.ts";
 
 export interface ValidationIssue {
   readonly path: string;
@@ -22,7 +28,7 @@ export type ValidationResult<T> = Readonly<
 
 export function validateCoreSnapshot(value: unknown): ValidationResult<CoreSnapshot> {
   const snapshot = snapshotClosedRecord(value);
-  if (snapshot === undefined || !hasExactKeys(snapshot, ["checks", "records"])) {
+  if (snapshot === undefined || !hasExactPlainRecordKeys(snapshot, ["checks", "records"])) {
     return invalid("$", "Core snapshot must contain only checks and records");
   }
   const checksInput = snapshotClosedArray(snapshot.checks);
@@ -63,7 +69,10 @@ function validateChecks(values: readonly unknown[]): ValidationResult<readonly C
   let previousCheckId: string | undefined;
   for (const [index, value] of values.entries()) {
     const check = snapshotClosedRecord(value);
-    if (check === undefined || !hasExactKeys(check, ["checkId", "displayName", "outcome"])) {
+    if (
+      check === undefined ||
+      !hasExactPlainRecordKeys(check, ["checkId", "displayName", "outcome"])
+    ) {
       return invalid(`$.checks[${index}]`, "Core Check must be closed");
     }
     const definition = validateCheckDescriptor({
@@ -126,7 +135,7 @@ function validateRecordRow(
   ownerIds: ReadonlySet<string>
 ): ValidationResult<CoreRecord> {
   const record = snapshotClosedRecord(value);
-  if (record === undefined || !hasExactKeys(record, ["checkId", "id", "data"]))
+  if (record === undefined || !hasExactPlainRecordKeys(record, ["checkId", "id", "data"]))
     return invalid(`$.records[${index}]`, "Core Record must be closed");
   if (
     typeof record.checkId !== "string" ||
@@ -159,7 +168,7 @@ function validateFinalOutcome(
   path: string
 ): ValidationResult<CheckOutcome> {
   if (outcome.status === "passed" || outcome.status === "failed") {
-    if (!hasExactKeys(outcome, ["status", "data"]))
+    if (!hasExactPlainRecordKeys(outcome, ["status", "data"]))
       return invalid(path, "Final outcome is not closed");
     const data = canonicalizeJsonObject(outcome.data);
     return data === undefined
@@ -173,7 +182,12 @@ function validateNotApplicableOutcome(
   outcome: Readonly<Record<string, unknown>>,
   path: string
 ): ValidationResult<CheckOutcome> {
-  if (!hasOptionalKeys(outcome, ["status"], ["reason"]))
+  if (
+    !hasRequiredAndOptionalRecordKeys(outcome, {
+      optional: ["reason"],
+      required: ["status"]
+    })
+  )
     return invalid(path, "Not-applicable outcome is not closed");
   const reason = validateReason(outcome.reason, false);
   return reason === null
@@ -189,7 +203,7 @@ function validateUnavailableOutcome(
   outcome: Readonly<Record<string, unknown>>,
   path: string
 ): ValidationResult<CheckOutcome> {
-  if (!hasExactKeys(outcome, ["status", "reason"]))
+  if (!hasExactPlainRecordKeys(outcome, ["status", "reason"]))
     return invalid(path, "Unavailable outcome is not closed");
   const reason = validateReason(outcome.reason, true);
   return reason === null || reason === undefined
@@ -203,26 +217,20 @@ function validateReason(
 ): Readonly<{ readonly code: string; readonly checkIds?: readonly string[] }> | null | undefined {
   if (value === undefined) return undefined;
   const reason = snapshotClosedRecord(value);
-  if (!isClosedReason(reason, allowCheckIds)) return null;
-  if (!hasOptionalKeys(reason, ["code"], allowCheckIds ? ["checkIds"] : [])) return null;
+  if (!isClosedCheckReason(reason, allowCheckIds)) return null;
+  if (
+    !hasRequiredAndOptionalRecordKeys(reason, {
+      optional: allowCheckIds ? ["checkIds"] : [],
+      required: ["code"]
+    })
+  )
+    return null;
   if (!Object.hasOwn(reason, "checkIds")) return Object.freeze({ code: reason.code });
   const normalizedCheckIds = normalizedReasonCheckIds(reason.checkIds, allowCheckIds);
   if (normalizedCheckIds === undefined) return null;
   return Object.freeze({ code: reason.code, checkIds: Object.freeze(normalizedCheckIds) });
 }
 
-function isClosedReason(
-  value: Readonly<Record<string, unknown>> | undefined,
-  allowCheckIds: boolean
-): value is Readonly<Record<string, unknown>> & Readonly<{ readonly code: string }> {
-  return (
-    value !== undefined &&
-    typeof value.code === "string" &&
-    value.code.length > 0 &&
-    hasOptionalKeys(value, ["code"], allowCheckIds ? ["checkIds"] : [])
-  );
-}
-
 function normalizedReasonCheckIds(
   value: unknown,
   allowCheckIds: boolean
@@ -243,24 +251,6 @@ function normalizedReasonCheckIds(
   return Object.freeze(normalizedCheckIds);
 }
 
-function hasExactKeys(value: Readonly<Record<string, unknown>>, keys: readonly string[]): boolean {
-  return (
-    Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key))
-  );
-}
-
-function hasOptionalKeys(
-  value: Readonly<Record<string, unknown>>,
-  required: readonly string[],
-  optional: readonly string[]
-): boolean {
-  const supported = new Set([...required, ...optional]);
-  return (
-    required.every((key) => Object.hasOwn(value, key)) &&
-    Object.keys(value).every((key) => supported.has(key))
-  );
-}
-
 function accepted<T>(value: T): ValidationResult<T> {
   return Object.freeze({ ok: true, value });
 }

package/src/check-settlement/outcome-normalization.ts

@@ -1,6 +1,12 @@
 import type { CheckOutcome } from "../check/check.ts";
 import { canonicalizeJsonObject } from "../data-boundary/canonical-data.ts";
-import { snapshotClosedArray, snapshotClosedRecord } from "../data-boundary/closed-values.ts";
+import {
+  hasExactPlainRecordKeys,
+  hasRequiredAndOptionalRecordKeys,
+  snapshotClosedArray,
+  snapshotClosedRecord
+} from "../data-boundary/closed-values.ts";
+import { isClosedCheckReason } from "./reason-shape.ts";
 
 interface OutcomeNormalizationInput {
   readonly knownCheckIds: ReadonlySet<string>;
@@ -28,7 +34,7 @@ function normalizeFinalOutcome(
   outcome: Readonly<Record<string, unknown>>
 ): CheckOutcome | undefined {
   if (outcome.status !== "passed" && outcome.status !== "failed") return undefined;
-  if (!hasExactKeys(outcome, ["status", "data"])) return undefined;
+  if (!hasExactPlainRecordKeys(outcome, ["status", "data"])) return undefined;
   const data = canonicalizeJsonObject(outcome.data);
   return data === undefined ? undefined : Object.freeze({ status: outcome.status, data });
 }
@@ -37,7 +43,13 @@ function normalizeNotApplicableOutcome(
   outcome: Readonly<Record<string, unknown>>,
   knownCheckIds: ReadonlySet<string>
 ): CheckOutcome | undefined {
-  if (!hasOptionalKeys(outcome, ["status"], ["reason"])) return undefined;
+  if (
+    !hasRequiredAndOptionalRecordKeys(outcome, {
+      optional: ["reason"],
+      required: ["status"]
+    })
+  )
+    return undefined;
   if (outcome.reason === undefined) return Object.freeze({ status: "not-applicable" });
   const reason = normalizeReason(outcome.reason, false, knownCheckIds);
   return reason === undefined ? undefined : Object.freeze({ status: "not-applicable", reason });
@@ -48,7 +60,7 @@ function normalizeUnavailableOutcome(
   productOutcome: boolean,
   knownCheckIds: ReadonlySet<string>
 ): CheckOutcome | undefined {
-  if (!hasExactKeys(outcome, ["status", "reason"])) return undefined;
+  if (!hasExactPlainRecordKeys(outcome, ["status", "reason"])) return undefined;
   const reason = normalizeReason(outcome.reason, productOutcome, knownCheckIds);
   return reason === undefined ? undefined : Object.freeze({ status: "unavailable", reason });
 }
@@ -59,24 +71,12 @@ function normalizeReason(
   knownCheckIds: ReadonlySet<string>
 ): Readonly<{ readonly code: string; readonly checkIds?: readonly string[] }> | undefined {
   const reason = snapshotClosedRecord(value);
-  if (!isClosedSessionReason(reason, allowCheckIds)) return undefined;
+  if (!isClosedCheckReason(reason, allowCheckIds)) return undefined;
   if (!Object.hasOwn(reason, "checkIds")) return Object.freeze({ code: reason.code });
   const checkIds = normalizedSessionReasonCheckIds(reason.checkIds, allowCheckIds, knownCheckIds);
   return checkIds === undefined ? undefined : Object.freeze({ code: reason.code, checkIds });
 }
 
-function isClosedSessionReason(
-  value: Readonly<Record<string, unknown>> | undefined,
-  allowCheckIds: boolean
-): value is Readonly<Record<string, unknown>> & Readonly<{ readonly code: string }> {
-  return (
-    value !== undefined &&
-    typeof value.code === "string" &&
-    value.code.length > 0 &&
-    hasOptionalKeys(value, ["code"], allowCheckIds ? ["checkIds"] : [])
-  );
-}
-
 function normalizedSessionReasonCheckIds(
   value: unknown,
   allowCheckIds: boolean,
@@ -98,21 +98,3 @@ function normalizedSessionReasonCheckIds(
   }
   return Object.freeze(checkIds);
 }
-
-function hasExactKeys(value: Readonly<Record<string, unknown>>, keys: readonly string[]): boolean {
-  return (
-    Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key))
-  );
-}
-
-function hasOptionalKeys(
-  value: Readonly<Record<string, unknown>>,
-  required: readonly string[],
-  optional: readonly string[]
-): boolean {
-  const supported = new Set([...required, ...optional]);
-  return (
-    required.every((key) => Object.hasOwn(value, key)) &&
-    Object.keys(value).every((key) => supported.has(key))
-  );
-}

package/src/check-settlement/reason-shape.ts

@@ -0,0 +1,20 @@
+import { hasRequiredAndOptionalRecordKeys } from "../data-boundary/closed-values.ts";
+
+export type ClosedCheckReason = Readonly<Record<string, unknown>> &
+  Readonly<{ readonly code: string }>;
+
+/** Recognizes the shared closed reason shape before owner-specific ID validation. */
+export function isClosedCheckReason(
+  value: Readonly<Record<string, unknown>> | undefined,
+  allowCheckIds: boolean
+): value is ClosedCheckReason {
+  return (
+    value !== undefined &&
+    typeof value.code === "string" &&
+    value.code.length > 0 &&
+    hasRequiredAndOptionalRecordKeys(value, {
+      optional: allowCheckIds ? ["checkIds"] : [],
+      required: ["code"]
+    })
+  );
+}

package/src/check-settlement/record-store.ts

@@ -3,15 +3,16 @@ import type { CoreRecord } from "./facts.ts";
 import { snapshotClosedRecord } from "../data-boundary/closed-values.ts";
 
 export type RecordSubmissionResult = "committed" | "rejected";
+
+const EMPTY_RECORDS: readonly CoreRecord[] = Object.freeze([]);
 export type RecordDiagnostic = "record-conflict" | "record-invalid";
 
 export interface CoreRecordSlot {
   readonly checkId: string;
   readonly diagnostics: Set<RecordDiagnostic>;
-  readonly recordIds: Set<string>;
 }
 
-/** Holds one Check's minimal Records without inventing a composite string identity. */
+/** Holds Check-local supplemental Records without inventing a composite string identity. */
 export class CoreRecordStore {
   readonly #recordsByCheckId = new Map<string, Map<string, CoreRecord>>();
 
@@ -23,30 +24,32 @@ export class CoreRecordStore {
     const id = recordId(rawIdentity);
     const data = canonicalizeJsonObject(rawData);
     if (id === undefined || data === undefined) return this.#reject(slot, "record-invalid");
-    if (slot.recordIds.has(id)) return this.#reject(slot, "record-conflict");
 
-    const record: CoreRecord = Object.freeze({ checkId: slot.checkId, id, data });
     let records = this.#recordsByCheckId.get(slot.checkId);
+    if (records?.has(id)) return this.#reject(slot, "record-conflict");
     if (records === undefined) {
       records = new Map<string, CoreRecord>();
       this.#recordsByCheckId.set(slot.checkId, records);
     }
+    const record: CoreRecord = Object.freeze({ checkId: slot.checkId, id, data });
     records.set(id, record);
-    slot.recordIds.add(id);
     return "committed";
   }
 
+  public recordsForCheckInCanonicalOrder(checkId: string): readonly CoreRecord[] {
+    const recordsById = this.#recordsByCheckId.get(checkId);
+    if (recordsById === undefined) return EMPTY_RECORDS;
+    return Object.freeze(
+      [...recordsById.values()].sort((left, right) => compareText(left.id, right.id))
+    );
+  }
+
   public recordsInCanonicalOrder(): readonly CoreRecord[] {
-    const records: CoreRecord[] = [];
-    for (const checkId of [...this.#recordsByCheckId.keys()].sort(compareText)) {
-      const byId = this.#recordsByCheckId.get(checkId);
-      if (byId === undefined) continue;
-      for (const id of [...byId.keys()].sort(compareText)) {
-        const record = byId.get(id);
-        if (record !== undefined) records.push(record);
-      }
-    }
-    return Object.freeze(records);
+    return Object.freeze(
+      [...this.#recordsByCheckId.keys()]
+        .sort(compareText)
+        .flatMap((checkId) => this.recordsForCheckInCanonicalOrder(checkId))
+    );
   }
 
   #reject(slot: CoreRecordSlot, diagnostic: RecordDiagnostic): "rejected" {

package/src/check-settlement/session.ts

@@ -6,7 +6,7 @@ import {
   type RecordDiagnostic,
   type RecordSubmissionResult
 } from "./record-store.ts";
-import type { CoreCheck, CoreSnapshot } from "./facts.ts";
+import type { CoreCheck, CoreRecord, CoreSnapshot } from "./facts.ts";
 import { validateCheckDescriptor } from "../check/descriptor-validation.ts";
 import { normalizeCheckOutcome } from "./outcome-normalization.ts";
 
@@ -39,6 +39,8 @@ export interface AuthorCheckSettlement {
 export interface CoreCheckSession {
   openCheckScope(checkId: string): TrustedCheckScope;
   readSettledCheckOutcome(checkId: string): CheckOutcome;
+  /** Product-private readback used only after this Check's terminal settlement. */
+  readSettledCheckRecords(checkId: string): readonly CoreRecord[];
   closeUnresolvedAsCancelled(): readonly CancelledCheckClosure[];
   freeze(): CoreSnapshot;
 }
@@ -95,8 +97,7 @@ function createSlots(registrations: readonly CoreCheckRegistration[]): CoreSlot[
       checkId: definition.value.checkId,
       definition: definition.value,
       diagnostics: new Set(),
-      lifecycle: { kind: "registered" },
-      recordIds: new Set()
+      lifecycle: { kind: "registered" }
     });
   }
   return slots.sort((left, right) =>
@@ -139,6 +140,14 @@ class CoreCheckSessionImpl implements CoreCheckSession {
     return slot.lifecycle.outcome;
   }
 
+  public readSettledCheckRecords(checkId: string): readonly CoreRecord[] {
+    const slot = this.#slotFor(checkId);
+    if (slot.lifecycle.kind !== "settled") {
+      coreInvariant("Core settled Check Records are not available");
+    }
+    return this.#recordStore.recordsForCheckInCanonicalOrder(checkId);
+  }
+
   public closeUnresolvedAsCancelled(): readonly CancelledCheckClosure[] {
     if (this.#snapshot !== undefined) {
       coreInvariant("Cancelled closure cannot mutate a frozen Core snapshot");

package/src/data-boundary/closed-values.ts

@@ -72,6 +72,15 @@ export function snapshotClosedRecord(
   }
 }
 
+/** Snapshots a closed plain record only when it has exactly the declared own keys. */
+export function snapshotExactClosedRecord(
+  value: unknown,
+  keys: readonly string[]
+): Readonly<Record<string, unknown>> | undefined {
+  const record = snapshotClosedRecord(value);
+  return record !== undefined && hasExactPlainRecordKeys(record, keys) ? record : undefined;
+}
+
 function closedArrayLength(shape: OwnDataShape): number | undefined {
   const descriptor = shape.descriptors.length;
   if (typeof descriptor?.value !== "number" || descriptor.enumerable !== false) return undefined;
@@ -124,3 +133,23 @@ export function hasRequiredAndOptionalRecordKeys(
     Object.keys(value).every((key) => supportedKeys.has(key))
   );
 }
+
+export interface ClosedPolicyRecordKeys {
+  readonly optional?: readonly string[];
+  readonly required?: readonly string[];
+}
+
+/** Snapshots an authoring record whose keys are limited to one required/optional policy. */
+export function snapshotClosedPolicyRecord(
+  value: unknown,
+  keys: ClosedPolicyRecordKeys
+): Readonly<Record<string, unknown>> | undefined {
+  const record = snapshotClosedRecord(value);
+  return record !== undefined &&
+    hasRequiredAndOptionalRecordKeys(record, {
+      optional: keys.optional ?? [],
+      required: keys.required ?? []
+    })
+    ? record
+    : undefined;
+}

package/src/data-boundary/value-shapes.ts

@@ -13,3 +13,15 @@ export function isUnknownArray(value: unknown): value is unknown[] {
 export function isStringArray(value: unknown): value is string[] {
   return isUnknownArray(value) && value.every((item) => typeof item === "string");
 }
+
+export function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0;
+}
+
+export function isPositiveSafeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+
+export function isNonNegativeSafeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}

package/src/index.ts

@@ -1,13 +1,18 @@
 /**
- * Vibe Check 是由项目在 Bun runtime 中调用的 TypeScript API，用于定义并执行项目质量 Check。
+ * Vibe Check 是由项目在 Node runtime 中调用的 TypeScript API，用于定义并执行项目质量 Check。
  * 所有公开能力从 package root 导入；package `README.md` 说明 consumer authoring、结果读取和分发范围。
  *
  * @packageDocumentation
  */
+export { cacheJsonByKey } from "./cache/cache-json-by-key.ts";
+export type { CacheJsonByKeyOptions, CacheJsonByKeyResult } from "./cache/cache-json-by-key.ts";
 export { duplicateDetection } from "./package-checks/duplicate-detection/default-check.ts";
 export { parseDuplicateDetectionData } from "./package-checks/duplicate-detection/final-data.ts";
 export type { DuplicateDetectionFinalData } from "./package-checks/duplicate-detection/final-data.ts";
 export type {
+  DuplicateDetectionFindingIdentity,
+  DuplicateDetectionFindingLocation,
+  DuplicateDetectionFindingWaiver,
   DuplicateDetectionOptions,
   ResolvedDuplicateDetectionOptions
 } from "./package-checks/duplicate-detection/options.ts";
@@ -28,16 +33,36 @@ export { functionMetrics } from "./package-checks/function-metrics/constructor.t
 export { parseFunctionMetricsData } from "./package-checks/function-metrics/final-data.ts";
 export type { FunctionMetricsFinalData } from "./package-checks/function-metrics/final-data.ts";
 export type {
+  FunctionMetricsFindingIdentity,
+  FunctionMetricsFindingMetric,
+  FunctionMetricsFindingWaiver,
   FunctionMetricsOptions,
   ResolvedFunctionMetricsOptions
 } from "./package-checks/function-metrics/options.ts";
 export type { FunctionMetricsUnavailableReasonCode } from "./package-checks/function-metrics/execution.ts";
 export type { FunctionMetricsRecordData } from "./package-checks/function-metrics/records.ts";
+export { secretDetection } from "./package-checks/secret-detection/default-check.ts";
+export { parseSecretDetectionData } from "./package-checks/secret-detection/final-data.ts";
+export type { SecretDetectionFinalData } from "./package-checks/secret-detection/final-data.ts";
+export type {
+  ResolvedSecretDetectionOptions,
+  SecretDetectionFindingIdentity,
+  SecretDetectionFindingWaiver,
+  SecretDetectionOptions
+} from "./package-checks/secret-detection/options.ts";
+export type { SecretDetectionUnavailableReasonCode } from "./package-checks/secret-detection/execution.ts";
+export type { SecretDetectionRecordData } from "./package-checks/secret-detection/records.ts";
 export { jsonSchemaValidation } from "./package-checks/json-schema-validation/default-check.ts";
 export { parseJsonSchemaValidationData } from "./package-checks/json-schema-validation/final-data.ts";
 export type { JsonSchemaValidationFinalData } from "./package-checks/json-schema-validation/final-data.ts";
 export type {
+  JsonSchemaIdentity,
+  JsonSchemaIdentityMode,
+  JsonSchemaInstanceBinding,
+  JsonSchemaReferenceResolution,
+  JsonSchemaReferenceSource,
   JsonSchemaValidationOptions,
+  RegisteredJsonSchema,
   ResolvedJsonSchemaValidationOptions
 } from "./package-checks/json-schema-validation/options.ts";
 export type {
@@ -82,6 +107,7 @@ export type { MarkdownLinkValidationRecordData } from "./package-checks/markdown
 export type { MarkdownLinkFindingReason } from "./package-checks/markdown-link-validation/local-resolver.ts";
 export type { FindingPolicy } from "./package-checks/code-quality-findings/policy.ts";
 export { reconcileFindingWaivers } from "./finding-waivers/reconciliation.ts";
+export { presentCheckFindings } from "./check/finding-presentation.ts";
 export type {
   FindingWaiver,
   FindingWaiverAudit,
@@ -91,6 +117,8 @@ export type {
   ReconcileFindingWaiversOptions
 } from "./finding-waivers/reconciliation.ts";
 export { defaultProjectFileSelection } from "./package-checks/project-files/configuration.ts";
+export { collectProjectFiles } from "./package-checks/project-files/public-collection.ts";
+export type { CollectProjectFilesOptions } from "./package-checks/project-files/public-collection.ts";
 export type {
   ProjectFileSelection,
   ProjectFileSelectionOptions,
@@ -99,19 +127,58 @@ export type {
 export { defineCheck, inherit } from "./check/check.ts";
 export type {
   Check,
+  CheckDependencies,
   CheckExecution,
   CheckExecutionContext,
   CheckPreflight,
   CheckPreflightResult,
+  CheckResourceClaims,
   CheckOutcome,
   CheckResult,
   CheckUnavailableReason,
   InheritableCheckCollection
 } from "./check/check.ts";
-export { defineConfig } from "./project-definition/project-definition.ts";
+export { defineAdmissionPolicy, defineConfig } from "./project-definition/project-definition.ts";
+export { createLearnedCriticalPathStrategy } from "./learned-critical-path/strategy.ts";
+export type {
+  LearnedCriticalPathObservation,
+  LearnedCriticalPathStrategyOptions
+} from "./learned-critical-path/strategy.ts";
+export { createAdmissionGraph } from "./project-run/task-scheduler/admission-core/core.ts";
 export type {
+  AdmissionPolicy,
+  AdmissionPolicyContext,
+  AdmissionPolicyMeasurement,
+  AdmissionProposal,
+  AdmissionCatalog,
+  AdmissionGraph,
+  AdmissionGraphInput,
+  AdmissionInspection,
+  AdmissionNonSelectableTask,
+  AdmissionRejectionReason,
+  AdmissionScopeLifecycle,
+  AdmissionSelectionRejectionReason,
+  AdmissionSelectionValidation,
+  AdmissionSelectionValidationRejectionReason,
+  AdmissionSettlementOutcome,
+  AdmissionSettledTask,
+  AdmissionState,
+  AdmissionTransitionResult,
+  CustomAdmissionPreparationContext,
+  CustomAdmissionStrategy,
+  PreparedCustomAdmissionStrategy,
+  ProgressPreviewFormatter,
   ProjectOutputs,
   ProjectDefinition,
+  SchedulerDecisionMeasurementCumulative,
+  SchedulerGraphSnapshot,
+  SchedulerMeasurementContext,
+  SchedulerMeasurementHook,
+  SchedulerMeasurementIntervalContribution,
+  SchedulerMeasurementActionObservationInterval,
+  SchedulerMeasurementActionObservation,
+  SchedulerMeasurementEffect,
+  SchedulerRawMeasurement,
   SchedulerPolicy
 } from "./project-definition/project-definition.ts";
 export type {
@@ -120,4 +187,5 @@ export type {
   RunControls
 } from "./project-run/controls/contract.ts";
 export { run } from "./project-run/run.ts";
+export type { RunOutputStatus, RunOutputStatuses } from "./project-run/outputs/status.ts";
 export type { RunResult } from "./project-run/result.ts";

package/src/learned-critical-path/duration-model/bounded-history.ts

@@ -0,0 +1,108 @@
+export const SCHEDULER_HISTORY_ENVELOPE_VERSION = "scheduler-history-envelope-v1";
+export const SCHEDULER_HISTORY_FILE_NAME = "scheduler-history.json";
+export const SCHEDULER_HISTORY_MODEL_VERSION = "scheduler-duration-model-v1";
+export const MAX_SCHEDULER_HISTORY_SAMPLES_PER_SERIES = 32;
+export const MAX_SCHEDULER_HISTORY_SERIES = 4_096;
+
+/** Bound persisted task-active durations so aggregates remain exact safe integers. */
+export const MAX_SCHEDULER_HISTORY_DURATION_MS = 2_147_483_647;
+
+/** Persisted terminal kind vocabulary; duration storage does not depend on Scheduler ownership. */
+export type SchedulerDurationSettlementKind =
+  | "completed"
+  | "prerequisite-unsatisfied"
+  | "failed"
+  | "blocked"
+  | "cancelled-before-start";
+
+export interface SchedulerHistorySample {
+  readonly durationMs: number;
+  readonly observationSequence: number;
+  readonly settlementKind: SchedulerDurationSettlementKind;
+}
+
+export interface SchedulerHistorySeries {
+  readonly identityDigest: string;
+  readonly latestObservationSequence: number;
+  readonly samples: readonly SchedulerHistorySample[];
+}
+
+/** Immutable, Product-private local model; the only persisted state is its closed envelope. */
+export interface SchedulerHistoryModel {
+  readonly latestObservationSequence: number;
+  readonly series: readonly SchedulerHistorySeries[];
+}
+
+export function emptySchedulerHistory(): SchedulerHistoryModel {
+  return Object.freeze({ latestObservationSequence: 0, series: Object.freeze([]) });
+}
+
+export function schedulerHistorySeries(
+  history: SchedulerHistoryModel,
+  identityDigest: string
+): SchedulerHistorySeries | undefined {
+  return history.series.find((series) => series.identityDigest === identityDigest);
+}
+
+export function freezeSchedulerHistoryModel(input: {
+  readonly latestObservationSequence: number;
+  readonly series: readonly SchedulerHistorySeries[];
+}): SchedulerHistoryModel {
+  return Object.freeze({
+    latestObservationSequence: input.latestObservationSequence,
+    series: Object.freeze(
+      [...input.series]
+        .sort((left, right) => compareText(left.identityDigest, right.identityDigest))
+        .map((series) =>
+          Object.freeze({
+            identityDigest: series.identityDigest,
+            latestObservationSequence: series.latestObservationSequence,
+            samples: Object.freeze(
+              series.samples.map((sample) =>
+                Object.freeze({
+                  durationMs: sample.durationMs,
+                  observationSequence: sample.observationSequence,
+                  settlementKind: sample.settlementKind
+                })
+              )
+            )
+          })
+        )
+    )
+  });
+}
+
+export function isSchedulerHistoryIdentityDigest(value: unknown): value is string {
+  return typeof value === "string" && /^sha256:[0-9a-f]{64}$/.test(value);
+}
+
+export function isSchedulerSettlementKind(
+  value: unknown
+): value is SchedulerDurationSettlementKind {
+  return (
+    value === "completed" ||
+    value === "prerequisite-unsatisfied" ||
+    value === "failed" ||
+    value === "blocked" ||
+    value === "cancelled-before-start"
+  );
+}
+
+export function isBoundedDurationMs(value: unknown): value is number {
+  return (
+    typeof value === "number" &&
+    Number.isFinite(value) &&
+    value >= 0 &&
+    value <= MAX_SCHEDULER_HISTORY_DURATION_MS
+  );
+}
+
+export function isObservationSequence(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}