@zxyycom/vibe-check 0.0.2 → 0.0.3

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

@@ -1,4 +1,3 @@
-import type { CheckProjectContext } from "../../check/check.ts";
 import {
   normalizeProjectDefinition,
   type DefinitionWarning,
@@ -7,33 +6,20 @@ import {
   type ResolvedProjectOutputs
 } from "../../project-definition/project-definition.ts";
 import type { CheckAggregation, RunControls } from "../controls/contract.ts";
-import {
-  createAdmissionStrategyProvider,
-  type AdmissionStrategyProviderFactory
-} from "../admission-strategy-provider/provider.ts";
-import { AdmissionStrategyPreparationFailure } from "../admission-strategy-provider/custom-strategy-preparation.ts";
-import type { PreparedAdmissionStrategy } from "../admission-strategy-provider/prepared-admission-strategy.ts";
+import type { AdmissionStrategyProviderFactory } from "../admission-strategy-provider/provider.ts";
 import { prepareTaskGraph } from "../task-scheduler/graph.ts";
-import { validateCheckAggregationSelection } from "../aggregation.ts";
+import { CheckAggregationFailure } from "../aggregation.ts";
 import { type CheckExecutionClock } from "../check-execution/resolved-checks.ts";
-import type { ResolvedCheckExecution } from "../check-execution/resolved-execution-result.ts";
 import { planStaticCheckGraph } from "../check-execution/plan.ts";
 import {
   type ProgressRefreshScheduler,
   type ProgressRendering,
   type ProgressWriterFactory
 } from "../progress-rendering/presentation.ts";
-import { finalizeInvocation } from "../completion/completion.ts";
-import { createProjectContext } from "../project-context.ts";
+import { closeAggregationFailure, finalizeInvocation } from "../completion/completion.ts";
 import type { ResolvedInvocationPaths } from "./paths.ts";
-import {
-  isCancelled,
-  planning,
-  preExecutionCancellation,
-  type NonConfigurationRunResult,
-  type RunDiagnostic,
-  type RunResult
-} from "../result.ts";
+import type { OutputStatuses } from "../outputs/status.ts";
+import { isCancelled, type NonConfigurationRunResult, type RunResult } from "../result.ts";
 import {
   diagnosticTags,
   summarizeDiagnosticValue,
@@ -41,9 +27,8 @@ import {
   type DiagnosticLoggingRouter
 } from "../diagnostic-logging/logger.ts";
 import { createInvocation } from "./creation.ts";
-import type { OutputStatuses } from "../outputs/status.ts";
-import { executeScheduler, type SchedulerExecution } from "./scheduler.ts";
-import { mapResolvedExecutionToRunCandidate } from "./candidate.ts";
+import { cancelledBeforeExecution, executionResult, planningResult } from "./candidates.ts";
+import { executePlannedInvocation } from "./execution.ts";
 export type Invocation = Readonly<{
   /** Product-private test seam; package `run` never accepts a provider factory. */
   readonly admissionStrategyProviderFactory: AdmissionStrategyProviderFactory | undefined;
@@ -83,17 +68,6 @@ export async function executeValidatedRun(
   dependencies: RunInvocationDependencies = {}
 ): Promise<RunResult> {
   const normalized = normalizeProjectDefinition(definition);
-  const aggregation = validateCheckAggregationSelection(
-    controls.checkAggregation,
-    normalized.checks.map((check) => check.definition.checkId)
-  );
-  if (!aggregation.ok)
-    return Object.freeze({
-      kind: "configuration",
-      definitionWarnings: Object.freeze([...definitionWarnings]),
-      diagnostic: aggregation.error
-    });
-
   const invocation = createInvocation({
     controls,
     definition,
@@ -103,15 +77,19 @@ export async function executeValidatedRun(
   });
   let candidate: NonConfigurationRunResult;
   try {
-    observeInvocationStarted(invocation, aggregation.value);
+    observeInvocationStarted(invocation, controls.checkAggregation);
     if (isCancelled(controls)) {
       candidate = cancelledBeforeExecution(invocation, "pre-work");
     } else if (!validateTaskGraph(invocation)) {
       candidate = planningResult(invocation, "task-graph-invalid");
     } else {
-      candidate = await executePlannedInvocation(invocation, aggregation.value);
+      candidate = await executePlannedInvocation(invocation, controls.checkAggregation);
+    }
+  } catch (error) {
+    if (error instanceof CheckAggregationFailure) {
+      closeAggregationFailure(invocation);
+      throw error.originalError;
     }
-  } catch {
     candidate = executionResult(invocation, "task-engine-failed");
   }
   return finalizeInvocation(invocation, candidate);
@@ -125,7 +103,7 @@ function observeInvocationStarted(
     event: "run.started",
     tags: diagnosticTags("RUN", "STARTED"),
     details: {
-      aggregation: aggregation ?? null,
+      aggregation: aggregation === undefined ? "default" : "custom",
       checkCount: invocation.normalized.checks.length,
       flags: summarizeDiagnosticValue(invocation.controls.flags ?? []),
       outputs: invocation.outputConfiguration,
@@ -164,145 +142,3 @@ function validateTaskGraph(invocation: Invocation): boolean {
     return false;
   }
 }
-async function executePlannedInvocation(
-  invocation: Invocation,
-  aggregation: CheckAggregation | undefined
-): Promise<NonConfigurationRunResult> {
-  if (isCancelled(invocation.controls)) return cancelledBeforeExecution(invocation, "pre-work");
-  return executePreparedInvocation(
-    invocation,
-    aggregation,
-    createProjectContext({ controls: invocation.controls, paths: invocation.paths })
-  );
-}
-async function executePreparedInvocation(
-  invocation: Invocation,
-  aggregation: CheckAggregation | undefined,
-  project: CheckProjectContext
-): Promise<NonConfigurationRunResult> {
-  if (isCancelled(invocation.controls)) return cancelledBeforeExecution(invocation, "planning");
-  let preparedStrategy: PreparedAdmissionStrategy;
-  try {
-    preparedStrategy = await prepareAdmissionStrategy(invocation);
-  } catch (error) {
-    if (error instanceof AdmissionStrategyPreparationFailure) {
-      return executionResult(invocation, "admission-strategy-preparation-failed");
-    }
-    throw error;
-  }
-  if (preparedStrategy.completion.kind === "measurement-hook") {
-    invocation.outputs.enableMeasurementHooks();
-  }
-  invocation.progressRendering.prepared(invocation.normalized.checks.length);
-  const executionStartedAt = invocation.clock.now();
-  const executed = await executeScheduler({ invocation, preparedStrategy, project });
-  if (isExecutionRunResult(executed)) return executed;
-  await completeAdmissionStrategyAfterTerminalMeasurement(
-    preparedStrategy,
-    executed,
-    invocation.outputs
-  );
-  return mapResolvedExecutionToRunCandidate({
-    aggregation,
-    executed,
-    executionStartedAt,
-    invocation
-  });
-}
-
-/** Composes one invocation-local strategy only after the static Task graph is valid. */
-async function prepareAdmissionStrategy(
-  invocation: Invocation
-): Promise<PreparedAdmissionStrategy> {
-  const graph = prepareTaskGraph(
-    planStaticCheckGraph(
-      invocation.normalized.checks,
-      invocation.normalized.declarative.scheduler.resourceCapacities
-    ),
-    invocation.normalized.declarative.scheduler.maxParallel
-  );
-  const admissionStrategyProviderFactory =
-    invocation.admissionStrategyProviderFactory ?? createAdmissionStrategyProvider;
-  const provider = admissionStrategyProviderFactory({
-    admissionPolicy: invocation.normalized.scheduler.admissionPolicy,
-    graph: graph.schedulerGraphSnapshot
-  });
-  return provider.prepare();
-}
-
-/** The prepared provider closes only after Scheduler terminal measurement and Hooks have settled. */
-async function completeAdmissionStrategyAfterTerminalMeasurement(
-  preparedStrategy: PreparedAdmissionStrategy,
-  executed: ResolvedCheckExecution,
-  outputs: OutputStatuses
-): Promise<void> {
-  const terminalMeasurement = executed.terminalSchedulerMeasurement;
-  if (terminalMeasurement === undefined) return;
-  switch (preparedStrategy.completion.kind) {
-    case "none":
-      return;
-    case "internal":
-      try {
-        await preparedStrategy.completion.complete(Object.freeze({ terminalMeasurement }));
-      } catch {
-        // Private learned lifecycle cannot revise sealed execution or public output facts.
-      }
-      return;
-    case "measurement-hook":
-      try {
-        await preparedStrategy.completion.complete(terminalMeasurement);
-        outputs.succeeded("measurementHooks");
-      } catch {
-        outputs.failed("measurementHooks");
-      }
-  }
-}
-
-function cancelledBeforeExecution(
-  invocation: Invocation,
-  phase: "pre-work" | "planning"
-): NonConfigurationRunResult {
-  invocation.diagnosticLogging.core.observe({
-    event: "run.cancelled",
-    tags: diagnosticTags("RUN", "CANCELLED"),
-    details: { phase }
-  });
-  return preExecutionCancellation(
-    invocation.declarativeFingerprint,
-    invocation.definitionWarnings,
-    invocation.outputs.value(),
-    phase
-  );
-}
-
-function planningResult(
-  invocation: Invocation,
-  code: Extract<RunDiagnostic["code"], "task-graph-invalid">
-): NonConfigurationRunResult {
-  return planning(
-    invocation.declarativeFingerprint,
-    invocation.definitionWarnings,
-    invocation.outputs.value(),
-    code
-  );
-}
-function executionResult(
-  invocation: Invocation,
-  code: Extract<
-    RunDiagnostic["code"],
-    "admission-strategy-preparation-failed" | "task-engine-failed"
-  >
-): NonConfigurationRunResult {
-  return Object.freeze({
-    kind: "execution",
-    declarativeFingerprint: invocation.declarativeFingerprint,
-    definitionWarnings: invocation.definitionWarnings,
-    diagnostic: Object.freeze({ code }),
-    outputs: invocation.outputs.value()
-  });
-}
-function isExecutionRunResult(
-  value: SchedulerExecution
-): value is Extract<NonConfigurationRunResult, { readonly kind: "execution" }> {
-  return "declarativeFingerprint" in value;
-}

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

@@ -28,14 +28,21 @@ export async function executeScheduler(input: SchedulerAdapterInput): Promise<Sc
       ...(invocation.diagnosticLoggingEnabled
         ? { schedulerDiagnosticLogger: invocation.diagnosticLogging.scheduler }
         : {}),
-      schedulerPerformanceDiagnostics: performanceDiagnostics,
-      schedulerMeasurementHooks: invocation.normalized.scheduler.measurementHooks,
-      onSchedulerMeasurementHookFailure: () => invocation.outputs.failed("measurementHooks"),
-      onSchedulerMeasurementHooksSettled: () => invocation.outputs.succeeded("measurementHooks"),
+      ...(performanceDiagnostics === undefined
+        ? {}
+        : { schedulerPerformanceDiagnostics: performanceDiagnostics }),
+      schedulerTerminalEffects: invocation.normalized.scheduler.terminalEffects,
+      onSchedulerTerminalEffectFailure: () => {
+        invocation.outputs.failed("terminalEffects");
+      },
+      onSchedulerTerminalEffectsSettled: () => {
+        invocation.outputs.succeeded("terminalEffects");
+      },
       maxParallel: invocation.normalized.declarative.scheduler.maxParallel,
       resourceCapacities: invocation.normalized.declarative.scheduler.resourceCapacities,
       invocationId: invocation.invocationId,
-      lifecycle: invocation.progressRendering.lifecycle,
+      checkLifecycle: invocation.progressRendering.checkLifecycle,
+      invocationLifecycle: invocation.progressRendering.invocationLifecycle,
       paths: invocation.paths,
       project: input.project,
       signal: invocation.controls.signal
@@ -49,7 +56,7 @@ function schedulerPerformanceDiagnostics(input: SchedulerAdapterInput) {
   const { invocation, preparedStrategy } = input;
   const shouldCollectSchedulerPerformanceDiagnostics =
     invocation.diagnosticLoggingEnabled ||
-    invocation.normalized.scheduler.measurementHooks.length > 0 ||
+    invocation.normalized.scheduler.terminalEffects.length > 0 ||
     preparedStrategy.admissionPolicy.requiresMeasurement === true ||
     preparedStrategy.requiresTerminalMeasurement;
   if (!shouldCollectSchedulerPerformanceDiagnostics) return undefined;

package/src/project-run/outputs/status.ts

@@ -33,15 +33,15 @@ export interface RunOutputStatuses {
   /** core 与 scheduler diagnostic channels 的 aggregate 状态。 */
   readonly diagnosticLogging: RunDiagnosticLoggingOutputStatus;
   /**
-   * Definition generic Hooks 与 prepared custom strategy 的 optional `complete` 所形成的 terminal participant
+   * Definition generic effects 与 prepared custom strategy 的 optional `terminalEffect` 所形成的 terminal participant
    * 状态；它不能由 RunControls 注入或覆盖。
    */
-  readonly measurementHooks: RunOutputStatus;
+  readonly terminalEffects: RunOutputStatus;
 }
 
 export interface OutputStatuses {
   /** Enables a runtime-only terminal participant after successful preparation. */
-  readonly enableMeasurementHooks: () => void;
+  readonly enableTerminalEffects: () => void;
   /** A diagnostic channel failure is isolated but updates the aggregate diagnostic output. */
   readonly failedDiagnosticChannel: (channel: DiagnosticChannel) => void;
   readonly failed: (output: keyof RunOutputStatuses) => void;
@@ -53,9 +53,9 @@ export interface OutputStatuses {
 export function createOutputStatuses(
   configuration: ProjectOutputs,
   diagnosticLoggingFiles: Readonly<Record<DiagnosticChannel, string | null>>,
-  initialMeasurementHooksEnabled: boolean
+  initialTerminalEffectsEnabled: boolean
 ): OutputStatuses {
-  let measurementHooksEnabled = initialMeasurementHooksEnabled;
+  let terminalEffectsEnabled = initialTerminalEffectsEnabled;
   const diagnosticChannelEnabled: Readonly<Record<DiagnosticChannel, boolean>> = Object.freeze({
     core: configuration.diagnosticLogging.enabled,
     scheduler: configuration.diagnosticLogging.enabled
@@ -64,14 +64,14 @@ export function createOutputStatuses(
     machinePublication: initialStatus(configuration.machinePublication.enabled),
     progressRendering: initialStatus(configuration.progressRendering.enabled),
     diagnosticLogging: initialStatus(configuration.diagnosticLogging.enabled),
-    measurementHooks: initialStatus(measurementHooksEnabled)
+    terminalEffects: initialStatus(terminalEffectsEnabled)
   };
   const diagnosticChannelStatuses: Record<DiagnosticChannel, RunOutputStatus["status"]> = {
     core: initialStatus(diagnosticChannelEnabled.core),
     scheduler: initialStatus(diagnosticChannelEnabled.scheduler)
   };
   const enabled = (output: keyof RunOutputStatuses): boolean =>
-    output === "measurementHooks" ? measurementHooksEnabled : configuration[output].enabled;
+    output === "terminalEffects" ? terminalEffectsEnabled : configuration[output].enabled;
   const refreshDiagnosticAggregate = (): void => {
     const enabledStatuses = DIAGNOSTIC_CHANNELS.filter(
       (channel) => diagnosticChannelEnabled[channel]
@@ -89,10 +89,10 @@ export function createOutputStatuses(
       : "not-run";
   };
   return Object.freeze({
-    enableMeasurementHooks: () => {
-      if (measurementHooksEnabled) return;
-      measurementHooksEnabled = true;
-      statuses.measurementHooks = "not-run";
+    enableTerminalEffects: () => {
+      if (terminalEffectsEnabled) return;
+      terminalEffectsEnabled = true;
+      statuses.terminalEffects = "not-run";
     },
     failedDiagnosticChannel: (channel: DiagnosticChannel) => {
       if (!diagnosticChannelEnabled[channel]) return;
@@ -129,9 +129,9 @@ export function createOutputStatuses(
           enabled: configuration.diagnosticLogging.enabled,
           status: statuses.diagnosticLogging
         }),
-        measurementHooks: Object.freeze({
-          enabled: measurementHooksEnabled,
-          status: statuses.measurementHooks
+        terminalEffects: Object.freeze({
+          enabled: terminalEffectsEnabled,
+          status: statuses.terminalEffects
         })
       })
   });
@@ -150,7 +150,7 @@ export function failedOutput(statuses: RunOutputStatuses): keyof RunOutputStatus
     "progressRendering",
     "machinePublication",
     "diagnosticLogging",
-    "measurementHooks"
+    "terminalEffects"
   ] as const)
     if (statuses[output].status === "failed") return output;
   return undefined;

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

@@ -3,6 +3,7 @@ import { dirname } from "node:path";
 
 import type {
   CheckExecutionLifecycle,
+  InvocationLifecycle,
   CheckSettledFact,
   CheckStartedFact
 } from "../check-execution/lifecycle.ts";
@@ -19,8 +20,9 @@ export interface ProgressRendering {
   /** Closes only an already-created file tee; it never creates a writer after pre-work termination. */
   readonly close: () => void;
   readonly final: (input: ProgressFinalFeedback) => void;
-  readonly lifecycle: CheckExecutionLifecycle;
-  readonly prepared: (totalChecks: number) => void;
+  readonly checkLifecycle: CheckExecutionLifecycle;
+  readonly invocationLifecycle: InvocationLifecycle;
+  readonly prepared: (totalChecks: number, quietPassOmissionConfiguredCount: number) => void;
 }
 export interface ProgressFinalFeedback {
   readonly counts: ProgressOutcomeCounts;
@@ -51,7 +53,11 @@ const defaultProgressRefreshScheduler: ProgressRefreshScheduler = Object.freeze(
   schedule: (refresh: () => void, intervalMs: number) => {
     const interval = setInterval(refresh, intervalMs);
     interval.unref();
-    return Object.freeze({ cancel: () => clearInterval(interval) });
+    return Object.freeze({
+      cancel: () => {
+        clearInterval(interval);
+      }
+    });
   }
 });
 
@@ -96,7 +102,9 @@ export function createProgressRendering(
     if (renderer !== undefined) return renderer;
     writer = createProgressTee({
       file: dependencies.file ?? null,
-      onFileFailure: () => statuses.failed("progressRendering"),
+      onFileFailure: () => {
+        statuses.failed("progressRendering");
+      },
       terminal: (dependencies.writerFactory ?? defaultProgressWriter)()
     });
     renderer = createProgressRenderer(writer, dependencies.clock, configuration);
@@ -156,9 +164,15 @@ export function createProgressRendering(
 
   return Object.freeze({
     close,
-    prepared: (totalChecks: number) => render(Object.freeze({ kind: "prepared", totalChecks })),
-    lifecycle: Object.freeze({
-      flagControlCompleted: () => render(Object.freeze({ kind: "flag-control-completed" })),
+    prepared: (totalChecks: number, quietPassOmissionConfiguredCount: number) => {
+      render(Object.freeze({ kind: "prepared", quietPassOmissionConfiguredCount, totalChecks }));
+    },
+    invocationLifecycle: Object.freeze({
+      selectionSettled: () => {
+        render(Object.freeze({ kind: "flag-control-completed" }));
+      }
+    }),
+    checkLifecycle: Object.freeze({
       settled: (fact: CheckSettledFact) => {
         render(
           Object.freeze({
@@ -169,7 +183,7 @@ export function createProgressRendering(
             messages: fact.messages,
             outcome: fact.outcome,
             records: fact.records,
-            visibility: fact.visibility
+            omitQuietPassedRow: fact.omitQuietPassedRow
           })
         );
         runningCheckIds.delete(fact.checkId);
@@ -178,7 +192,12 @@ export function createProgressRendering(
       started: (fact: CheckStartedFact) => {
         runningCheckIds.add(fact.checkId);
         render(
-          Object.freeze({ kind: "started", checkId: fact.checkId, displayName: fact.displayName })
+          Object.freeze({
+            kind: "started",
+            checkId: fact.checkId,
+            displayName: fact.displayName,
+            omitQuietPassedRow: fact.omitQuietPassedRow
+          })
         );
         startRefresh();
       }
@@ -198,15 +217,18 @@ export function createProgressRendering(
   });
 }
 function inertProgressRendering(): ProgressRendering {
-  const lifecycle = Object.freeze({
-    flagControlCompleted: (): void => undefined,
+  const invocationLifecycle = Object.freeze({
+    selectionSettled: (): void => undefined
+  });
+  const checkLifecycle = Object.freeze({
     settled: (_fact: CheckSettledFact): void => undefined,
     started: (_fact: CheckStartedFact): void => undefined
   });
   return Object.freeze({
     close: (): void => undefined,
-    prepared: (_totalChecks: number): void => undefined,
-    lifecycle,
+    prepared: (_totalChecks: number, _quietPassOmissionConfiguredCount: number): void => undefined,
+    checkLifecycle,
+    invocationLifecycle,
     final: (_input: ProgressFinalFeedback): void => undefined
   });
 }

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

@@ -24,21 +24,23 @@ const NAMED_CONTROL_ESCAPES: Readonly<Partial<Record<string, string>>> = Object.
 
 export function formatRunningRow(
   input: Readonly<{
-    readonly displayIndex: number;
+    readonly displayIndex: number | undefined;
     readonly displayName: string;
     readonly elapsedMs: number | null;
     readonly totalChecks: number;
   }>
 ): string {
   const elapsed = input.elapsedMs === null ? "" : ` | ${formatDuration(input.elapsedMs)}`;
-  return `  [${input.displayIndex}/${input.totalChecks}] ${escapeTerminalText(input.displayName)} | running${elapsed}\n`;
+  const ordinal =
+    input.displayIndex === undefined ? "·" : `[${input.displayIndex}/${input.totalChecks}]`;
+  return `  ${ordinal} ${escapeTerminalText(input.displayName)} | running${elapsed}\n`;
 }
 
 export function shouldPresentSettledFeedback(
   feedback: Extract<ProgressFeedback, { readonly kind: "settled" }>
 ): boolean {
   return (
-    feedback.visibility !== "attention" ||
+    !feedback.omitQuietPassedRow ||
     feedback.outcome.status !== "passed" ||
     feedback.messages.length > 0 ||
     feedback.records.length > 0
@@ -71,7 +73,7 @@ export function formatFlagConditionNotMatchedBlock(
 
 export function formatSettledBlock(
   input: Readonly<{
-    readonly completionOrdinal: number;
+    readonly completionOrdinal: number | undefined;
     readonly displayName: string;
     readonly durationMs: number | null;
     readonly messages: readonly CheckMessage[];
@@ -86,14 +88,22 @@ export function formatSettledBlock(
   const reason = reasonForOutcome(input.outcome);
   const duration = input.durationMs === null ? "not run" : formatDuration(input.durationMs);
   const reasonSuffix = reason === undefined ? "" : ` | ${escapeTerminalText(reason)}`;
-  const row = `  [${input.completionOrdinal}/${input.totalChecks}] ${escapeTerminalText(input.displayName)} | ${status} | ${duration}${reasonSuffix}\n`;
+  const ordinal =
+    input.completionOrdinal === undefined
+      ? "·"
+      : `[${input.completionOrdinal}/${input.totalChecks}]`;
+  const row = `  ${ordinal} ${escapeTerminalText(input.displayName)} | ${status} | ${duration}${reasonSuffix}\n`;
   const recordPreview = formatRecords(input.records, input.progressRendering);
   const messagePreview = formatMessages(input.messages, input.usesColor, input.progressRendering);
   return `${row}${recordPreview}${messagePreview}`;
 }
 
 export function formatFinalSummary(
-  input: Extract<ProgressFeedback, { readonly kind: "final" }>
+  input: Extract<ProgressFeedback, { readonly kind: "final" }> &
+    Readonly<{
+      readonly quietPassOmissionConfiguredCount: number;
+      readonly quietPassOmittedCount: number;
+    }>
 ): string {
   return [
     "",
@@ -104,6 +114,9 @@ export function formatFinalSummary(
     `  failed: ${input.counts.failed}`,
     `  not applicable: ${input.counts.notApplicable}`,
     `  unavailable: ${input.counts.unavailable}`,
+    ...(input.quietPassOmissionConfiguredCount === 0
+      ? []
+      : [`  quiet-pass rows omitted: ${input.quietPassOmittedCount}`]),
     `  elapsed: ${formatDuration(input.elapsedMs)}`,
     ""
   ].join("\n");
@@ -194,7 +207,7 @@ function formattedPreviewText(
 function observeRejectedPromise(value: unknown): void {
   if (types.isPromise(value)) {
     // The intrinsic call observes a real Promise without reading a caller-controlled `.then`.
-    // eslint-disable-next-line typescript/no-floating-promises -- rendering must not await formatter misuse.
+    // oxlint-disable-next-line typescript/no-floating-promises -- rendering must not await formatter misuse.
     void Promise.prototype.then.call(value, undefined, () => undefined);
   }
 }

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

@@ -17,6 +17,7 @@ import {
 interface RunningCheck {
   readonly checkId: string;
   readonly displayName: string;
+  readonly omitQuietPassedRow: boolean;
   readonly startedAtMs: number;
   elapsedMs: number | null;
 }
@@ -29,6 +30,8 @@ export class ProgressRendererController implements ProgressRenderer {
   private readonly writer: ProgressWriter;
   private completedCount = 0;
   private readonly flagConditionNotMatchedDisplayNames: string[] = [];
+  private quietPassOmissionConfiguredCount = 0;
+  private quietPassOmittedCount = 0;
   private preparedTotal: number | undefined;
   private renderedRunningRows = 0;
   private readonly running: RunningCheck[] = [];
@@ -58,7 +61,7 @@ export class ProgressRendererController implements ProgressRenderer {
   render(feedback: ProgressFeedback): void {
     switch (feedback.kind) {
       case "prepared":
-        this.prepare(feedback.totalChecks);
+        this.prepare(feedback.totalChecks, feedback.quietPassOmissionConfiguredCount);
         return;
       case "flag-control-completed":
         this.completeFlagControl();
@@ -74,10 +77,15 @@ export class ProgressRendererController implements ProgressRenderer {
     }
   }
 
-  private prepare(totalChecks: number): void {
+  private prepare(totalChecks: number, quietPassOmissionConfiguredCount: number): void {
     if (this.preparedTotal !== undefined) throw new Error("Progress feedback was prepared twice");
     this.preparedTotal = totalChecks;
-    this.writer.write(`Vibe Check\ntotal ${totalChecks} checks\n\nChecks:\n`);
+    this.quietPassOmissionConfiguredCount = quietPassOmissionConfiguredCount;
+    const configuredSuffix =
+      quietPassOmissionConfiguredCount === 0
+        ? ""
+        : ` · ${quietPassOmissionConfiguredCount} configured for quiet-pass omission`;
+    this.writer.write(`Vibe Check\ntotal ${totalChecks} checks${configuredSuffix}\n\nChecks:\n`);
   }
 
   private start(feedback: Extract<ProgressFeedback, { readonly kind: "started" }>): void {
@@ -87,6 +95,7 @@ export class ProgressRendererController implements ProgressRenderer {
     this.running.push({
       checkId: feedback.checkId,
       displayName: feedback.displayName,
+      omitQuietPassedRow: feedback.omitQuietPassedRow,
       elapsedMs: null,
       startedAtMs: this.clock.now()
     });
@@ -103,7 +112,7 @@ export class ProgressRendererController implements ProgressRenderer {
     } else if (shouldPresentSettledFeedback(feedback)) {
       this.writer.write(
         formatSettledBlock({
-          completionOrdinal: this.completedCount,
+          completionOrdinal: feedback.omitQuietPassedRow ? undefined : this.completedCount,
           displayName: feedback.displayName,
           durationMs: feedback.durationMs,
           messages: feedback.messages,
@@ -114,6 +123,8 @@ export class ProgressRendererController implements ProgressRenderer {
           progressRendering: this.progressRendering
         })
       );
+    } else {
+      this.quietPassOmittedCount += 1;
     }
     if (this.refreshesRunningRegion) this.redrawRunningRegion();
   }
@@ -124,7 +135,13 @@ export class ProgressRendererController implements ProgressRenderer {
       throw new Error("Progress feedback finalized while Checks are still running");
     }
     this.flushFlagConditionNotMatchedChecks();
-    this.writer.write(formatFinalSummary(feedback));
+    this.writer.write(
+      formatFinalSummary({
+        ...feedback,
+        quietPassOmissionConfiguredCount: this.quietPassOmissionConfiguredCount,
+        quietPassOmittedCount: this.quietPassOmittedCount
+      })
+    );
   }
 
   private completeFlagControl(): void {
@@ -156,9 +173,9 @@ export class ProgressRendererController implements ProgressRenderer {
     for (const [index, check] of this.running.entries()) {
       this.writer.write(
         formatRunningRow({
-          displayIndex: this.completedCount + index + 1,
           displayName: check.displayName,
           elapsedMs: check.elapsedMs,
+          displayIndex: check.omitQuietPassedRow ? undefined : this.completedCount + index + 1,
           totalChecks
         })
       );