@zxyycom/vibe-check 0.0.2 → 0.0.3

package/src/{finding-waivers → package-tools/finding-waivers}/reconciliation.ts

@@ -3,7 +3,7 @@ import {
   canonicalJsonText,
   type CanonicalJsonObject,
   type CanonicalJsonValue
-} from "../data-boundary/canonical-data.ts";
+} from "../../data-boundary/canonical-data.ts";
 
 /** 由采用方声明、用于匹配一个 finding 的语义身份与豁免理由。 */
 export interface FindingWaiver<Identity> {
@@ -61,8 +61,8 @@ export interface ReconcileFindingWaiversOptions<Finding, Identity> {
   readonly findings: readonly Finding[];
   /** 从完整 finding 提取调用方选择的稳定语义身份。 */
   readonly identify: (finding: Finding) => Identity;
-  /** 要与识别器输出进行 canonical structural matching 的 waiver。 */
-  readonly waivers: readonly FindingWaiver<Identity>[];
+  /** 要对账的 waiver；省略或 undefined 等同于空数组，仍验证全部 finding identity。 */
+  readonly waivers?: readonly FindingWaiver<Identity>[] | undefined;
 }
 
 /** 独立 waiver reconciliation 的完整输出，保留 finding 处置和每项配置审计。 */
@@ -96,7 +96,13 @@ export function reconcileFindingWaivers<Finding, Identity>(
   const matchedWaiverIndexes = options.findings.map((finding) => {
     const identity = canonicalIdentity(options.identify(finding), "finding identity");
     const waiverIndex = waiverIndexesByIdentity.get(identity);
-    if (waiverIndex !== undefined) matchCounts[waiverIndex] += 1;
+    if (waiverIndex !== undefined) {
+      const matchCount = matchCounts[waiverIndex];
+      if (matchCount === undefined) {
+        throw new Error(`Finding waiver match index is out of range: ${waiverIndex}`);
+      }
+      matchCounts[waiverIndex] = matchCount + 1;
+    }
     return waiverIndex;
   });
   const waiverAudits = Object.freeze(
@@ -118,9 +124,7 @@ export function reconcileFindingWaivers<Finding, Identity>(
   return Object.freeze({ findings, waiverAudits });
 }
 
-function materializeWaivers<Identity>(
-  waivers: readonly FindingWaiver<Identity>[]
-): readonly MaterializedFindingWaiver[] {
+function materializeWaivers(waivers: unknown = []): readonly MaterializedFindingWaiver[] {
   const canonicalWaivers = canonicalizeJsonValue(waivers);
   if (canonicalWaivers === undefined || !isCanonicalArray(canonicalWaivers)) {
     throw new TypeError("Finding waivers must be canonical JSON arrays");
@@ -140,7 +144,11 @@ function materializeWaiver(value: CanonicalJsonValue): MaterializedFindingWaiver
   if (typeof reason !== "string" || reason.length === 0) {
     throw new TypeError("Finding waiver reasons must be non-empty strings");
   }
-  return Object.freeze({ identity: value.identity, reason });
+  const identity = value.identity;
+  if (identity === undefined) {
+    throw new TypeError("Finding waiver identity must be present");
+  }
+  return Object.freeze({ identity, reason });
 }
 
 function isCanonicalObject(value: CanonicalJsonValue): value is CanonicalJsonObject {

package/src/{learned-critical-path → package-tools/learned-critical-path}/duration-model/prediction.ts

@@ -1,6 +1,9 @@
 import { createHash } from "node:crypto";
 
-import { canonicalJsonBytes, type CanonicalJsonValue } from "../../data-boundary/canonical-data.ts";
+import {
+  canonicalJsonBytes,
+  type CanonicalJsonValue
+} from "../../../data-boundary/canonical-data.ts";
 import {
   SCHEDULER_HISTORY_MODEL_VERSION,
   schedulerHistorySeries,
@@ -48,7 +51,7 @@ export function createSchedulerHistoryIdentity(input: {
   });
 }
 
-/** Forms learned means first, then one project median prior, without invoking preflight. */
+/** Forms learned means first, then one project median prior, without invoking preparation. */
 export function createSchedulerPredictionSnapshot(
   history: SchedulerHistoryModel,
   inputs: readonly SchedulerPredictionInput[],

package/src/{learned-critical-path → package-tools/learned-critical-path}/duration-model/preparation.ts

@@ -1,4 +1,4 @@
-import type { SchedulerMeasurementContext } from "../../project-definition/project-definition.ts";
+import type { SchedulerMeasurementContext } from "../../../project-definition/project-definition.ts";
 import { recordSchedulerHistory, type SchedulerHistoryRecordingObservation } from "./recording.ts";
 import {
   createSchedulerPredictionSnapshot,
@@ -54,8 +54,10 @@ export async function prepareSchedulerDurationModel(input: {
             prediction,
             rawMeasurement: terminalMeasurement.rawMeasurement,
             settledTasks: terminalMeasurement.execution.settledTasks,
-            maxSamplesPerSeries: input.maxSamplesPerSeries,
-            maxSeries: input.maxSeries
+            ...(input.maxSamplesPerSeries === undefined
+              ? {}
+              : { maxSamplesPerSeries: input.maxSamplesPerSeries }),
+            ...(input.maxSeries === undefined ? {} : { maxSeries: input.maxSeries })
           });
           const writeObservation = await writeSchedulerHistory(
             input.stateDirectory,

package/src/{learned-critical-path → package-tools/learned-critical-path}/duration-model/recording.ts

@@ -1,7 +1,4 @@
-import type {
-  SchedulerMeasurementAdmission,
-  SchedulerRawMeasurement
-} from "../../project-definition/project-definition.ts";
+import type { SchedulerRawMeasurement } from "../../../project-definition/project-definition.ts";
 import {
   freezeSchedulerHistoryModel,
   isBoundedDurationMs,
@@ -13,6 +10,10 @@ import {
 } from "./bounded-history.ts";
 import { predictionForTask, type SchedulerPredictionSnapshot } from "./prediction.ts";
 
+type SchedulerMeasurementAdmission = NonNullable<
+  SchedulerRawMeasurement["timingFacts"]
+>["admissions"][number];
+
 export type SchedulerHistoryRecordingObservation =
   | Readonly<{
       readonly acceptedSampleCount: number;

package/src/{learned-critical-path → package-tools/learned-critical-path}/duration-model/storage.ts

@@ -2,12 +2,11 @@ import { promises as fs } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 
-import { canonicalJsonText } from "../../data-boundary/canonical-data.ts";
+import { canonicalJsonText } from "../../../data-boundary/canonical-data.ts";
 import {
-  hasExactPlainRecordKeys,
   snapshotClosedArray,
-  snapshotClosedRecord
-} from "../../data-boundary/closed-values.ts";
+  snapshotExactClosedRecord
+} from "../../../data-boundary/closed-values.ts";
 import {
   emptySchedulerHistory,
   freezeSchedulerHistoryModel,
@@ -126,8 +125,8 @@ type ParsedEnvelope =
   | Readonly<{ readonly kind: "incompatible" }>;
 
 function parseSchedulerHistoryEnvelope(value: unknown): ParsedEnvelope {
-  const envelope = snapshotClosedRecord(value);
-  if (envelope === undefined || !hasExactPlainRecordKeys(envelope, ENVELOPE_KEYS)) {
+  const envelope = snapshotExactClosedRecord(value, ENVELOPE_KEYS);
+  if (envelope === undefined) {
     return Object.freeze({ kind: "invalid" });
   }
   if (
@@ -179,8 +178,8 @@ function parseSeries(value: unknown): readonly SchedulerHistorySeries[] | undefi
 }
 
 function parseSeriesEntry(value: unknown): SchedulerHistorySeries | undefined {
-  const record = snapshotClosedRecord(value);
-  if (record === undefined || !hasExactPlainRecordKeys(record, SERIES_KEYS)) return undefined;
+  const record = snapshotExactClosedRecord(value, SERIES_KEYS);
+  if (record === undefined) return undefined;
   if (
     !isSchedulerHistoryIdentityDigest(record.identityDigest) ||
     !isObservationSequence(record.latestObservationSequence)
@@ -223,8 +222,8 @@ function parseSamples(value: unknown): readonly SchedulerHistorySample[] | undef
 }
 
 function parseSample(value: unknown): SchedulerHistorySample | undefined {
-  const record = snapshotClosedRecord(value);
-  if (record === undefined || !hasExactPlainRecordKeys(record, SAMPLE_KEYS)) return undefined;
+  const record = snapshotExactClosedRecord(value, SAMPLE_KEYS);
+  if (record === undefined) return undefined;
   if (
     !isBoundedDurationMs(record.durationMs) ||
     !isPositiveObservationSequence(record.observationSequence) ||

package/src/{learned-critical-path → package-tools/learned-critical-path}/selection-layers.ts

@@ -1,7 +1,7 @@
 import type {
   AdmissionPolicyContext,
   SchedulerGraphSnapshot
-} from "../project-definition/project-definition.ts";
+} from "../../project-definition/project-definition.ts";
 
 type Candidate = AdmissionPolicyContext["candidates"][number];
 type Task = SchedulerGraphSnapshot["tasks"][number];
@@ -44,8 +44,7 @@ function isTightening(
 ): boolean {
   const scope = scopeForCandidate(candidate, taskById, scopeById);
   return (
-    scope !== undefined &&
-    scope.activationTaskIds.includes(candidate.taskId) &&
+    scope?.activationTaskIds.includes(candidate.taskId) === true &&
     !activeScopeIds.has(scope.id) &&
     scope.maxParallel < maxParallel
   );

package/src/{learned-critical-path → package-tools/learned-critical-path}/static-decision.ts

@@ -2,7 +2,7 @@ import type {
   AdmissionPolicyContext,
   AdmissionProposal,
   SchedulerGraphSnapshot
-} from "../project-definition/project-definition.ts";
+} from "../../project-definition/project-definition.ts";
 import { learnedSelectionLayers, scopeForCandidate } from "./selection-layers.ts";
 
 type Candidate = AdmissionPolicyContext["candidates"][number];

package/src/{learned-critical-path → package-tools/learned-critical-path}/strategy.ts

@@ -1,13 +1,16 @@
 import { isAbsolute } from "node:path";
 
-import { canonicalizeJsonValue, type CanonicalJsonValue } from "../data-boundary/canonical-data.ts";
+import {
+  canonicalizeJsonValue,
+  type CanonicalJsonValue
+} from "../../data-boundary/canonical-data.ts";
 import type {
   AdmissionPolicyContext,
   AdmissionProposal,
   CustomAdmissionStrategy,
   SchedulerGraphSnapshot,
   SchedulerMeasurementContext
-} from "../project-definition/project-definition.ts";
+} from "../../project-definition/project-definition.ts";
 import { prepareSchedulerDurationModel } from "./duration-model/preparation.ts";
 import { learnedSelectionLayers } from "./selection-layers.ts";
 import { staticDecision } from "./static-decision.ts";
@@ -20,7 +23,7 @@ import {
   createSchedulerCriticalPathSnapshot,
   criticalPathScoreForTask,
   type SchedulerCriticalPathSnapshot
-} from "../project-run/task-scheduler/critical-path-ranking.ts";
+} from "./critical-path-ranking.ts";
 
 /** 公开 learned critical-path prepared strategy 的调用方配置。 */
 export interface LearnedCriticalPathStrategyOptions {
@@ -94,7 +97,7 @@ export function createLearnedCriticalPathStrategy(
       return Object.freeze({
         decide: (context: AdmissionPolicyContext) =>
           learnedDecision(context, durationModel.prediction, criticalPath, options),
-        complete: async (context: SchedulerMeasurementContext) => {
+        terminalEffect: async (context: SchedulerMeasurementContext) => {
           const recorded = await durationModel.record(context);
           if (recorded.kind === "failed" || recorded.writeObservation === "failed") {
             observe(options, { kind: "recording-unavailable" });

package/src/project-definition/check-tree/authoring.ts

@@ -1,4 +1,8 @@
 import type { CheckDescriptor } from "../../check/descriptor.ts";
+import {
+  getDefinedHandoffProviderIdentity,
+  type HandoffProviderIdentity
+} from "../../check/handoff-provider-identity.ts";
 import { snapshotClosedArray } from "../../data-boundary/closed-values.ts";
 import {
   parseCheckAuthoringData,
@@ -22,7 +26,8 @@ export interface ParsedCheck {
   readonly dependsOn: ParsedCheckCollection | undefined;
   readonly displayName: string;
   readonly enabledByFlags: ParsedCheckFieldPrelude["enabledByFlags"];
-  readonly execution: ParsedCheckFieldPrelude["execution"];
+  readonly execute: ParsedCheckFieldPrelude["execute"];
+  readonly handoff: HandoffProviderIdentity | null;
   readonly maxParallel: number | undefined;
   readonly mutex: ParsedCheckCollection | undefined;
   readonly observes: ParsedCheckCollection | undefined;
@@ -30,8 +35,8 @@ export interface ParsedCheck {
   readonly options: object | null;
   readonly path: string;
   readonly parseData: TrustedDataParser | null;
-  readonly preflight: ParsedCheckFieldPrelude["preflight"];
-  readonly visibility: ParsedCheckFields["visibility"];
+  readonly prepare: ParsedCheckFieldPrelude["prepare"];
+  readonly omitQuietPassedRow: ParsedCheckFields["omitQuietPassedRow"];
 }
 
 export interface ParsedCheckTree {
@@ -70,9 +75,10 @@ export function parseCheckTreeAuthoring(value: unknown): ParsedCheckTree | undef
 }
 
 function parseCheck(value: unknown, path: string, state: ParseState): ParsedCheck | undefined {
+  const handoffProviderIdentity = getDefinedHandoffProviderIdentity(value);
   const data = parseCheckAuthoringData(value);
   if (data === undefined) return undefined;
-  const prelude = parseCheckFieldPrelude(data);
+  const prelude = parseCheckFieldPrelude(data, handoffProviderIdentity);
   if (prelude === undefined) return undefined;
   const checks = parseChildren(data, path, state);
   if (checks === undefined) return undefined;
@@ -89,7 +95,8 @@ function parseCheck(value: unknown, path: string, state: ParseState): ParsedChec
     dependsOn: scheduling.dependsOn,
     displayName: data.displayName,
     enabledByFlags: fields.enabledByFlags,
-    execution: fields.execution,
+    execute: fields.execute,
+    handoff: fields.handoff,
     maxParallel: scheduling.maxParallel,
     mutex: scheduling.mutex,
     observes: scheduling.observes,
@@ -97,8 +104,8 @@ function parseCheck(value: unknown, path: string, state: ParseState): ParsedChec
     options: fields.options,
     path,
     parseData: fields.parseData,
-    preflight: fields.preflight,
-    visibility: fields.visibility
+    prepare: fields.prepare,
+    omitQuietPassedRow: fields.omitQuietPassedRow
   });
 }
 
@@ -126,6 +133,6 @@ function warnForMeaninglessCheck(
   path: string,
   state: ParseState
 ): void {
-  if (fields.execution !== null || checks.length > 0) return;
+  if (fields.execute !== null || checks.length > 0) return;
   state.warnings.push(Object.freeze({ code: "meaningless-check", path, checkId: data.checkId }));
 }

package/src/project-definition/check-tree/check-fields-authoring.ts

@@ -1,15 +1,10 @@
 import type { CheckDescriptor } from "../../check/descriptor.ts";
-import {
-  type CheckVisibility,
-  type CheckFlagEnablement,
-  type CheckFlagEnablementMode,
-  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";
 import { validateCheckDescriptor } from "../../check/descriptor-validation.ts";
 import { snapshotJsonObject } from "../../check/options-snapshot.ts";
 import { snapshotClosedRecord } from "../../data-boundary/closed-values.ts";
-import { parseUniqueIdentifiers } from "./collection-authoring.ts";
+import { hasOnlyKeys, parseFlagCondition } from "./flag-conditions.ts";
 
 export type TrustedDataParser = (this: void, ...parameters: never[]) => unknown;
 
@@ -21,24 +16,20 @@ 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;
-}
-
-interface ParsedFlagEnablementControl extends Readonly<Record<string, unknown>> {
-  readonly flags: unknown;
-  readonly mode: CheckFlagEnablementMode;
-  readonly propagateDependsOn?: true;
+  readonly prepare: CheckPreparation | null;
 }
 
 const CHECK_KEYS = [
@@ -48,26 +39,28 @@ const CHECK_KEYS = [
   "dependsOn",
   "displayName",
   "enabledByFlags",
-  "execution",
+  "execute",
+  "handoff",
   "maxParallel",
   "mutex",
   "options",
   "observes",
   "parseData",
-  "preflight",
+  "prepare",
   "resourceClaims",
-  "visibility"
+  "omitQuietPassedRow"
 ] as const;
-const FLAG_ENABLEMENT_KEYS = ["flags", "mode", "propagateDependsOn"] as const;
+const FLAG_ENABLEMENT_EXPRESSION_KEYS = ["when", "propagateDependsOn"] as const;
 
 const CONTAINER_CHECK_FIELDS: ParsedCheckFields = Object.freeze({
   definition: null,
   enabledByFlags: null,
-  execution: null,
+  execute: null,
+  handoff: null,
   options: null,
   parseData: null,
-  preflight: null,
-  visibility: null
+  prepare: null,
+  omitQuietPassedRow: null
 });
 
 export function parseCheckAuthoringData(value: unknown): CheckAuthoringData | undefined {
@@ -88,47 +81,74 @@ function hasValidCheckIdentity(
 }
 
 export function parseCheckFieldPrelude(
-  data: CheckAuthoringData
+  data: CheckAuthoringData,
+  handoffProviderIdentity: HandoffProviderIdentity | undefined
 ): ParsedCheckFieldPrelude | undefined {
   const execution = parseExecution(data);
   if (execution === undefined) return undefined;
+  const handoff = parseHandoff(data, handoffProviderIdentity);
+  if (handoff === undefined) return undefined;
   const parseData = parseDataParser(data);
   if (parseData === undefined) return undefined;
-  const preflight = parsePreflight(data);
-  if (preflight === undefined) return undefined;
+  const preparation = parsePreparation(data);
+  if (preparation === undefined) return undefined;
   const enabledByFlags = parseEnabledByFlags(data);
   return enabledByFlags === undefined
     ? undefined
-    : Object.freeze({ enabledByFlags, execution, parseData, preflight });
+    : Object.freeze({
+        enabledByFlags,
+        execute: execution,
+        handoff,
+        parseData,
+        prepare: preparation
+      });
 }
 
 export function parseCheckFields(
   data: CheckAuthoringData,
   prelude: ParsedCheckFieldPrelude
 ): ParsedCheckFields | undefined {
-  if (prelude.execution === null) {
-    return Object.hasOwn(data, "options") ||
-      Object.hasOwn(data, "enabledByFlags") ||
-      Object.hasOwn(data, "visibility") ||
-      prelude.parseData !== null ||
-      prelude.preflight !== null
-      ? undefined
-      : CONTAINER_CHECK_FIELDS;
+  if (prelude.execute === null) {
+    return containerHasExecutableFields(data, prelude) ? undefined : CONTAINER_CHECK_FIELDS;
   }
+  return parseExecutableCheckFields(data, prelude);
+}
+
+/** Container nodes cannot carry values that only an executable callback can consume. */
+function containerHasExecutableFields(
+  data: CheckAuthoringData,
+  prelude: ParsedCheckFieldPrelude
+): boolean {
+  return (
+    Object.hasOwn(data, "options") ||
+    Object.hasOwn(data, "enabledByFlags") ||
+    prelude.handoff !== null ||
+    Object.hasOwn(data, "omitQuietPassedRow") ||
+    prelude.parseData !== null ||
+    prelude.prepare !== null
+  );
+}
+
+/** Parses the callback-owned fields that form one executable Check definition. */
+function parseExecutableCheckFields(
+  data: CheckAuthoringData,
+  prelude: ParsedCheckFieldPrelude
+): ParsedCheckFields | undefined {
   const definition = parseDefinition(data);
   if (definition === undefined) return undefined;
   const options = parseOptions(data);
   if (options === undefined) return undefined;
-  const visibility = parseVisibility(data);
-  if (visibility === undefined) return undefined;
+  const omitQuietPassedRow = parseOmitQuietPassedRow(data);
+  if (omitQuietPassedRow === undefined) return undefined;
   return Object.freeze({
     definition,
     enabledByFlags: prelude.enabledByFlags,
-    execution: prelude.execution,
+    execute: prelude.execute,
+    handoff: prelude.handoff,
     options,
     parseData: prelude.parseData,
-    preflight: prelude.preflight,
-    visibility
+    prepare: prelude.prepare,
+    omitQuietPassedRow
   });
 }
 
@@ -136,9 +156,21 @@ function hasOnlyCheckKeys(data: Readonly<Record<string, unknown>>): boolean {
   return Object.keys(data).every((key) => CHECK_KEYS.some((checkKey) => checkKey === key));
 }
 
-function parseExecution(data: CheckAuthoringData): CheckExecution | null | undefined {
-  if (!Object.hasOwn(data, "execution")) return null;
-  return isTrustedFunction<CheckExecution>(data.execution) ? data.execution : undefined;
+function parseExecution(
+  data: CheckAuthoringData
+): NonNullable<Check["execute"]> | null | undefined {
+  if (!Object.hasOwn(data, "execute")) return null;
+  return isTrustedFunction<NonNullable<Check["execute"]>>(data.execute) ? data.execute : undefined;
+}
+
+function parseHandoff(
+  data: CheckAuthoringData,
+  handoffProviderIdentity: HandoffProviderIdentity | undefined
+): HandoffProviderIdentity | null | undefined {
+  if (!Object.hasOwn(data, "handoff")) return null;
+  return data.handoff === true && handoffProviderIdentity !== undefined
+    ? handoffProviderIdentity
+    : undefined;
 }
 
 function parseDataParser(data: CheckAuthoringData): TrustedDataParser | null | undefined {
@@ -146,9 +178,9 @@ function parseDataParser(data: CheckAuthoringData): TrustedDataParser | null | u
   return isTrustedFunction<TrustedDataParser>(data.parseData) ? data.parseData : undefined;
 }
 
-function parsePreflight(data: CheckAuthoringData): CheckPreflight | null | undefined {
-  if (!Object.hasOwn(data, "preflight")) return null;
-  return isTrustedFunction<CheckPreflight>(data.preflight) ? data.preflight : undefined;
+function parsePreparation(data: CheckAuthoringData): CheckPreparation | null | undefined {
+  if (!Object.hasOwn(data, "prepare")) return null;
+  return isTrustedFunction<CheckPreparation>(data.prepare) ? data.prepare : undefined;
 }
 
 function isTrustedFunction<FunctionType extends (...parameters: never[]) => unknown>(
@@ -174,54 +206,37 @@ function parseOptions(data: CheckAuthoringData): object | undefined {
 
 function parseEnabledByFlags(data: CheckAuthoringData): CheckFlagEnablement | null | undefined {
   if (!Object.hasOwn(data, "enabledByFlags")) return null;
-  const control = parseFlagEnablementControl(data.enabledByFlags);
-  if (control === undefined) return undefined;
-  const flags = parseUniqueIdentifiers(control.flags);
-  return flags === undefined ? undefined : canonicalFlagEnablement(control, flags);
+  return parseFlagEnablementControl(data.enabledByFlags);
 }
 
-function parseFlagEnablementControl(value: unknown): ParsedFlagEnablementControl | undefined {
+/** Parses one closed flag-enablement field without validating its Project flag references. */
+export function parseFlagEnablementControl(value: unknown): CheckFlagEnablement | undefined {
   const control = snapshotClosedRecord(value);
-  if (control === undefined || !hasOnlyFlagEnablementKeys(control)) return undefined;
-  return hasFlagEnablementFields(control) ? control : undefined;
-}
-
-function hasFlagEnablementFields(
-  control: Readonly<Record<string, unknown>>
-): control is ParsedFlagEnablementControl {
-  if (!Object.hasOwn(control, "flags") || !Object.hasOwn(control, "mode")) return false;
-  if (!isCheckFlagEnablementMode(control.mode)) return false;
-  return !Object.hasOwn(control, "propagateDependsOn") || control.propagateDependsOn === true;
-}
-
-function canonicalFlagEnablement(
-  control: ParsedFlagEnablementControl,
-  flags: readonly string[]
-): CheckFlagEnablement | undefined {
-  const [firstFlag, ...remainingFlags] = [...flags].sort();
-  if (firstFlag === undefined) return undefined;
-  const canonicalFlags: [string, ...string[]] = [firstFlag, ...remainingFlags];
-  return Object.freeze({
-    flags: Object.freeze(canonicalFlags),
-    mode: control.mode,
-    ...(control.propagateDependsOn === true ? { propagateDependsOn: true as const } : {})
-  });
-}
-
-function hasOnlyFlagEnablementKeys(control: Readonly<Record<string, unknown>>): boolean {
-  return Object.keys(control).every((key) =>
-    FLAG_ENABLEMENT_KEYS.some((allowed) => allowed === key)
-  );
+  if (
+    control === undefined ||
+    !hasOnlyKeys(control, FLAG_ENABLEMENT_EXPRESSION_KEYS) ||
+    !Object.hasOwn(control, "when")
+  ) {
+    return undefined;
+  }
+  const when = parseFlagCondition(control.when);
+  const propagateDependsOn = parsePropagation(control);
+  return when === undefined || propagateDependsOn === undefined
+    ? undefined
+    : Object.freeze({
+        when,
+        ...(propagateDependsOn ? { propagateDependsOn: true as const } : {})
+      });
 }
 
-function isCheckFlagEnablementMode(value: unknown): value is CheckFlagEnablementMode {
-  return value === "all" || value === "any" || value === "none" || value === "not-all";
+function parsePropagation(control: Readonly<Record<string, unknown>>): boolean | undefined {
+  if (!Object.hasOwn(control, "propagateDependsOn")) return false;
+  return control.propagateDependsOn === true ? true : undefined;
 }
 
-function parseVisibility(data: CheckAuthoringData): CheckVisibility | undefined {
-  if (!Object.hasOwn(data, "visibility")) return "always";
-  const visibility = data.visibility;
-  return visibility === undefined || visibility === "always" || visibility === "attention"
-    ? (visibility ?? "always")
+function parseOmitQuietPassedRow(data: CheckAuthoringData): boolean | undefined {
+  if (!Object.hasOwn(data, "omitQuietPassedRow")) return false;
+  return data.omitQuietPassedRow === undefined || data.omitQuietPassedRow === true
+    ? (data.omitQuietPassedRow ?? false)
     : undefined;
 }