@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-run/diagnostic-logging/observation-rendering.ts

@@ -0,0 +1,203 @@
+import type { DiagnosticObservation } from "./logger.ts";
+import { renderSafeDiagnosticDetail } from "./diagnostic-detail-rendering.ts";
+
+export function renderDiagnosticObservation(
+  input: Readonly<{
+    readonly elapsedMs: number;
+    readonly invocationId: string | undefined;
+    readonly observation: DiagnosticObservation;
+    readonly sequence: number;
+  }>
+): string {
+  const tags = input.observation.tags.map((tag) => `[${escapeLogHeaderField(tag)}]`).join(" ");
+  const invocation =
+    input.invocationId === undefined ? "" : ` invocationId=${JSON.stringify(input.invocationId)}`;
+  const header = `#${String(input.sequence).padStart(6, "0")} +${formatElapsed(input.elapsedMs)} ${tags}${invocation} ${escapeLogHeaderField(input.observation.event)}`;
+  return renderFactLines(header, diagnosticFacts(input.observation));
+}
+
+/** Keeps author-controlled header fields on one physical header line. */
+function escapeLogHeaderField(text: string): string {
+  let escaped = "";
+  for (const character of text) {
+    if (character === "\\") {
+      escaped += "\\\\";
+      continue;
+    }
+    const codeUnit = character.charCodeAt(0);
+    escaped +=
+      codeUnit <= 0x1f ||
+      (codeUnit >= 0x7f && codeUnit <= 0x9f) ||
+      codeUnit === 0x5b ||
+      codeUnit === 0x5d ||
+      codeUnit === 0x2028 ||
+      codeUnit === 0x2029
+        ? `\\u${codeUnit.toString(16).padStart(4, "0")}`
+        : character;
+  }
+  return escaped;
+}
+
+function diagnosticFacts(observation: DiagnosticObservation): readonly string[] {
+  if (observation.details === undefined) return Object.freeze([]);
+  const rendered = renderSafeDiagnosticDetail(observation.details);
+  if (!rendered.ok)
+    return Object.freeze([`details=unavailable:${escapeLogHeaderField(rendered.reason)}`]);
+
+  const value: unknown = JSON.parse(rendered.text);
+  const facts: string[] = [];
+  flattenDiagnosticFacts(value, [], facts, observation);
+  return Object.freeze(facts);
+}
+
+function flattenDiagnosticFacts(
+  value: unknown,
+  path: readonly string[],
+  facts: string[],
+  observation: DiagnosticObservation
+): void {
+  if (Array.isArray(value)) {
+    flattenDiagnosticArrayFacts(value, path, facts, observation);
+    return;
+  }
+
+  if (value !== null && typeof value === "object") {
+    flattenDiagnosticRecordFacts(value, path, facts, observation);
+    return;
+  }
+
+  facts.push(`${factKey(path)}=${factValue(path, value)}`);
+}
+
+function flattenDiagnosticArrayFacts(
+  value: readonly unknown[],
+  path: readonly string[],
+  facts: string[],
+  observation: DiagnosticObservation
+): void {
+  const inline = JSON.stringify(value);
+  if (inline.length <= MAX_INLINE_DIAGNOSTIC_VALUE_CHARACTERS) {
+    facts.push(`${factKey(path)}=${inline}`);
+    return;
+  }
+  const arrayPath = path.length === 0 ? ["details"] : path;
+  for (let index = 0; index < value.length; index += 1) {
+    flattenDiagnosticFacts(value[index], [...arrayPath, String(index)], facts, observation);
+  }
+}
+
+function flattenDiagnosticRecordFacts(
+  value: object,
+  path: readonly string[],
+  facts: string[],
+  observation: DiagnosticObservation
+): void {
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    facts.push(`${factKey(path)}={}`);
+    return;
+  }
+  for (const [key, nested] of entries) {
+    if (path.length === 0 && isTopLevelFactRepresentedByTag(observation, key, nested)) continue;
+    flattenDiagnosticFacts(nested, [...path, key], facts, observation);
+  }
+}
+
+/** Omits only exact producer facts already visible in the observation's filter tags. */
+function isTopLevelFactRepresentedByTag(
+  observation: DiagnosticObservation,
+  key: string,
+  value: unknown
+): boolean {
+  if (typeof value !== "string") return false;
+  if (observation.event === "scheduler.decision") {
+    if (key === "kind") return observation.tags.includes(value.toUpperCase());
+    return key === "taskId" && observation.tags.includes(`TASK:${value}`);
+  }
+  return (
+    observation.event === "record.reported" &&
+    key === "result" &&
+    observation.tags.includes(value.toUpperCase())
+  );
+}
+
+const MAX_INLINE_DIAGNOSTIC_VALUE_CHARACTERS = 120;
+
+function factKey(path: readonly string[]): string {
+  if (path.length === 0) return "details";
+  const joined = path.join(".");
+  return /^[A-Za-z_][A-Za-z0-9_.-]*$/u.test(joined) ? joined : JSON.stringify(joined);
+}
+
+function factValue(path: readonly string[], value: unknown): string {
+  const key = path.at(-1);
+  if (typeof value === "number" && key?.endsWith("Ms") === true) {
+    return String(Math.round(value * 1_000) / 1_000);
+  }
+  return JSON.stringify(value);
+}
+
+const MAX_DIAGNOSTIC_LINE_CHARACTERS = 200;
+
+function renderFactLines(header: string, facts: readonly string[]): string {
+  if (facts.length === 0) return `${header}\n`;
+
+  const lines: string[] = [];
+  let current = header;
+  for (const fact of facts) {
+    if (current.length + 1 + fact.length <= MAX_DIAGNOSTIC_LINE_CHARACTERS) {
+      current += ` ${fact}`;
+      continue;
+    }
+
+    lines.push(current);
+    const firstCapacity = MAX_DIAGNOSTIC_LINE_CHARACTERS - "│ ".length;
+    const continuationCapacity = MAX_DIAGNOSTIC_LINE_CHARACTERS - "│   ".length;
+    let offset = 0;
+    let prefix = "│ ";
+    while (fact.length - offset > (prefix === "│ " ? firstCapacity : continuationCapacity)) {
+      const capacity = prefix === "│ " ? firstCapacity : continuationCapacity;
+      const end = diagnosticChunkEnd(fact, offset, capacity);
+      lines.push(`${prefix}${fact.slice(offset, end)}`);
+      offset = end;
+      prefix = "│   ";
+    }
+    current = `${prefix}${fact.slice(offset)}`;
+  }
+  lines.push(current);
+  return `${lines.join("\n")}\n`;
+}
+
+function diagnosticChunkEnd(text: string, offset: number, capacity: number): number {
+  let end = offset + capacity;
+  const preferredMinimum = offset + Math.floor(capacity * 0.6);
+  for (let index = end - 1; index >= preferredMinimum; index -= 1) {
+    if (text[index] === " ") {
+      end = index;
+      break;
+    }
+    if (text[index] === ",") {
+      end = index + 1;
+      break;
+    }
+  }
+  if (
+    end < text.length &&
+    text.charCodeAt(end - 1) >= 0xd800 &&
+    text.charCodeAt(end - 1) <= 0xdbff &&
+    text.charCodeAt(end) >= 0xdc00 &&
+    text.charCodeAt(end) <= 0xdfff
+  ) {
+    end -= 1;
+  }
+  return end;
+}
+
+function formatElapsed(elapsedMs: number): string {
+  const totalMilliseconds = Math.round(elapsedMs);
+  const hours = Math.floor(totalMilliseconds / 3_600_000);
+  const minutes = Math.floor((totalMilliseconds % 3_600_000) / 60_000);
+  const seconds = Math.floor((totalMilliseconds % 60_000) / 1_000);
+  const milliseconds = totalMilliseconds % 1_000;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(milliseconds).padStart(3, "0")}`;
+}

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

@@ -0,0 +1,99 @@
+import { aggregateEffectiveChecks } from "../aggregation.ts";
+import { completeInvocation, type CoreExecution } from "../completion/completion.ts";
+import type { CheckAggregation } from "../controls/contract.ts";
+import { diagnosticTags } from "../diagnostic-logging/logger.ts";
+import type { Invocation } from "./run.ts";
+import { elapsedSince, outcomeCounts } from "./progress.ts";
+import { executionCancellation, type NonConfigurationRunResult } from "../result.ts";
+import type { ResolvedCheckExecution } from "../check-execution/resolved-execution-result.ts";
+
+export type ResolvedExecutionCandidateInput = Readonly<{
+  readonly aggregation: CheckAggregation | undefined;
+  readonly executed: ResolvedCheckExecution;
+  readonly executionStartedAt: number;
+  readonly invocation: Invocation;
+}>;
+
+/** Maps a sealed Scheduler result into the Run-owned candidate before terminal output closure. */
+export function mapResolvedExecutionToRunCandidate(
+  input: ResolvedExecutionCandidateInput
+): NonConfigurationRunResult {
+  const { executed, invocation } = input;
+  if (executed.kind === "admission-policy-failed") return admissionPolicyFailure(invocation);
+
+  if (executed.kind === "cancelled") {
+    invocation.progressRendering.final({
+      counts: outcomeCounts(executed.snapshot),
+      elapsedMs: elapsedSince(input.executionStartedAt, invocation.clock),
+      execution: executed.kind
+    });
+    return cancelledExecutionCandidate(invocation, executed);
+  }
+  return completedExecutionCandidate(
+    invocation,
+    input.aggregation,
+    executed,
+    input.executionStartedAt
+  );
+}
+
+function admissionPolicyFailure(
+  invocation: Invocation
+): Extract<NonConfigurationRunResult, { readonly kind: "execution" }> {
+  return Object.freeze({
+    kind: "execution",
+    declarativeFingerprint: invocation.declarativeFingerprint,
+    definitionWarnings: invocation.definitionWarnings,
+    diagnostic: Object.freeze({ code: "admission-policy-failed" }),
+    outputs: invocation.outputs.value()
+  });
+}
+
+function cancelledExecutionCandidate(
+  invocation: Invocation,
+  executed: Extract<ResolvedCheckExecution, { readonly kind: "cancelled" }>
+): NonConfigurationRunResult {
+  invocation.diagnosticLogging.core.observe({
+    event: "run.execution.cancelled",
+    tags: diagnosticTags("RUN", "EXECUTION", "CANCELLED"),
+    details: { checkCount: executed.snapshot.checks.length }
+  });
+  return executionCancellation({
+    checkDurations: executed.checkDurations,
+    checkMessages: executed.checkMessages,
+    declarativeFingerprint: invocation.declarativeFingerprint,
+    definitionWarnings: invocation.definitionWarnings,
+    outputs: invocation.outputs.value(),
+    snapshot: executed.snapshot
+  });
+}
+
+function completedExecutionCandidate(
+  invocation: Invocation,
+  aggregation: CheckAggregation | undefined,
+  executed: Extract<ResolvedCheckExecution, { readonly kind: "completed" }>,
+  executionStartedAt: number
+): NonConfigurationRunResult {
+  const aggregate = aggregateEffectiveChecks(
+    executed.snapshot,
+    executed.effectiveCheckIds,
+    aggregation
+  );
+  invocation.diagnosticLogging.core.observe({
+    event: "run.aggregation.completed",
+    tags: diagnosticTags("RUN", "AGGREGATION", "COMPLETED"),
+    details: { aggregate, aggregation: aggregation === undefined ? "default" : "custom" }
+  });
+  const core: CoreExecution = Object.freeze({
+    aggregate,
+    checkDurations: executed.checkDurations,
+    checkMessages: executed.checkMessages,
+    snapshot: executed.snapshot
+  });
+  invocation.progressRendering.final({
+    counts: outcomeCounts(executed.snapshot),
+    elapsedMs: elapsedSince(executionStartedAt, invocation.clock),
+    execution: "completed"
+  });
+  return completeInvocation(invocation, core);
+}

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

@@ -0,0 +1,56 @@
+import { diagnosticTags } from "../diagnostic-logging/logger.ts";
+import {
+  planning,
+  preExecutionCancellation,
+  type NonConfigurationRunResult,
+  type RunDiagnostic
+} from "../result.ts";
+import type { Invocation } from "./run.ts";
+
+/** Records a pre-execution cancellation as the Run-owned candidate result. */
+export 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
+  );
+}
+
+/** Constructs the planning failure candidate after the static graph has been rejected. */
+export function planningResult(
+  invocation: Invocation,
+  code: Extract<RunDiagnostic["code"], "task-graph-invalid">
+): NonConfigurationRunResult {
+  return planning(
+    invocation.declarativeFingerprint,
+    invocation.definitionWarnings,
+    invocation.outputs.value(),
+    code
+  );
+}
+
+/** Constructs a pre-settlement execution failure without revising existing output facts. */
+export 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()
+  });
+}

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

@@ -0,0 +1,120 @@
+import { randomUUID } from "node:crypto";
+
+import {
+  createDeclarativeFingerprint,
+  type DefinitionWarning,
+  type NormalizedProjectDefinition,
+  type ProjectDefinition,
+  type ResolvedProjectOutputs
+} from "../../project-definition/project-definition.ts";
+import type { RunControls } from "../controls/contract.ts";
+import {
+  createDiagnosticLogger,
+  createDiagnosticLoggingRouter
+} from "../diagnostic-logging/logger.ts";
+import type { Invocation, RunInvocationDependencies } from "./run.ts";
+import { createOutputStatuses } from "../outputs/status.ts";
+import { effectiveOutputs } from "../outputs/configuration.ts";
+import { resolveInvocationPaths } from "./paths.ts";
+import { createProgressRendering } from "../progress-rendering/presentation.ts";
+
+const SYSTEM_MONOTONIC_CLOCK: Invocation["clock"] = Object.freeze({
+  now: () => performance.now()
+});
+
+export interface InvocationCreationInput {
+  readonly controls: RunControls;
+  readonly definition: ProjectDefinition;
+  readonly definitionWarnings: readonly DefinitionWarning[];
+  readonly dependencies: RunInvocationDependencies;
+  readonly normalized: NormalizedProjectDefinition;
+}
+
+/** Creates immutable invocation-owned output state before any planning or execution work. */
+export function createInvocation(input: InvocationCreationInput): Invocation {
+  const outputConfiguration = effectiveOutputs(input.definition, input.controls);
+  const clock = input.dependencies.clock ?? SYSTEM_MONOTONIC_CLOCK;
+  const diagnosticLoggingEnabled = outputConfiguration.diagnosticLogging.enabled;
+  const startedAtUtc = captureOutputCreationTimestamp(outputConfiguration, input.dependencies);
+  const identity = createInvocationIdentity();
+  const paths = resolveInvocationPaths({
+    checkArtifactBaseDirectory: input.controls.checkArtifactBaseDirectory,
+    checkIds: input.normalized.checks.map((check) => check.definition.checkId),
+    diagnosticLogFileNaming: input.controls.diagnosticLogFileNaming ?? "unique",
+    diagnosticLogSuffix: diagnosticLoggingEnabled
+      ? diagnosticLogSuffix(requireStartedAtUtc(startedAtUtc), identity.uuid)
+      : undefined,
+    outputConfiguration,
+    progressLogFile: input.controls.progressLogFile,
+    projectRoot: input.controls.projectRoot ?? process.cwd()
+  });
+  const outputs = createOutputStatuses(
+    outputConfiguration,
+    paths.diagnosticLoggingReadbackFiles,
+    input.normalized.scheduler.terminalEffects.length > 0
+  );
+  const diagnosticLogging = createDiagnosticLoggingRouter({
+    clock,
+    coreFile: paths.diagnosticLoggingFiles.core,
+    factory: input.dependencies.diagnosticLoggerFactory ?? createDiagnosticLogger,
+    invocationId: identity.id,
+    schedulerFile: paths.diagnosticLoggingFiles.scheduler
+  });
+
+  return Object.freeze({
+    admissionStrategyProviderFactory: input.dependencies.admissionStrategyProviderFactory,
+    clock,
+    controls: input.controls,
+    declarativeFingerprint: createDeclarativeFingerprint(input.normalized.declarative),
+    definition: input.definition,
+    definitionWarnings: Object.freeze([...input.definitionWarnings]),
+    diagnosticLogging,
+    diagnosticLoggingEnabled,
+    outputConfiguration,
+    outputs,
+    invocationId: identity.id,
+    paths,
+    normalized: input.normalized,
+    progressRendering: createProgressRendering(outputConfiguration.progressRendering, outputs, {
+      clock,
+      ...(input.dependencies.progressRefreshScheduler === undefined
+        ? {}
+        : { refreshScheduler: input.dependencies.progressRefreshScheduler }),
+      ...(input.dependencies.progressWriterFactory === undefined
+        ? {}
+        : { writerFactory: input.dependencies.progressWriterFactory }),
+      file: paths.progressLogFile
+    }),
+    startedAtUtc
+  });
+}
+
+function captureOutputCreationTimestamp(
+  outputConfiguration: ResolvedProjectOutputs,
+  dependencies: RunInvocationDependencies
+): string | null {
+  if (
+    !outputConfiguration.diagnosticLogging.enabled &&
+    !outputConfiguration.machinePublication.enabled
+  )
+    return null;
+  return (dependencies.wallClock?.now() ?? new Date()).toISOString();
+}
+
+function createInvocationIdentity(): Readonly<{
+  readonly id: string;
+  readonly uuid: string;
+}> {
+  const uuid = randomUUID();
+  return Object.freeze({ id: `invocation/v1:${uuid}`, uuid });
+}
+
+function diagnosticLogSuffix(startedAtUtc: string, invocationUuid: string): string {
+  const compactUtc = startedAtUtc.replaceAll("-", "").replaceAll(":", "");
+  return `${compactUtc}-${invocationUuid}`;
+}
+
+function requireStartedAtUtc(startedAtUtc: string | null): string {
+  if (startedAtUtc === null) throw new Error("Enabled output requires an invocation timestamp");
+  return startedAtUtc;
+}

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

@@ -0,0 +1,136 @@
+import type { CheckProjectContext } from "../../check/check.ts";
+import type { CheckAggregation } from "../controls/contract.ts";
+import { createAdmissionStrategyProvider } 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 { prepareTaskGraph } from "../task-scheduler/graph.ts";
+import type { ResolvedCheckExecution } from "../check-execution/resolved-execution-result.ts";
+import { planStaticCheckGraph } from "../check-execution/plan.ts";
+import { prepareProjectChanges } from "../changes/git.ts";
+import { createProjectContext } from "../project-context.ts";
+import type { OutputStatuses } from "../outputs/status.ts";
+import { isCancelled, type NonConfigurationRunResult } from "../result.ts";
+import { mapResolvedExecutionToRunCandidate } from "./candidate.ts";
+import { cancelledBeforeExecution, executionResult } from "./candidates.ts";
+import type { Invocation } from "./run.ts";
+import { executeScheduler, type SchedulerExecution } from "./scheduler.ts";
+
+const EMPTY_EFFECTIVE_FLAGS: readonly string[] = Object.freeze([]);
+
+/** Executes the post-validation invocation phases, from change preparation through Scheduler completion. */
+export async function executePlannedInvocation(
+  invocation: Invocation,
+  aggregation: CheckAggregation | undefined
+): Promise<NonConfigurationRunResult> {
+  if (isCancelled(invocation.controls)) return cancelledBeforeExecution(invocation, "pre-work");
+  const preparedChanges =
+    invocation.normalized.changes === undefined
+      ? undefined
+      : prepareProjectChanges({
+          callerFlags: invocation.controls.flags ?? [],
+          changes: invocation.normalized.changes,
+          projectRoot: invocation.paths.projectRoot
+        });
+  const effectiveFlags =
+    preparedChanges?.effectiveFlags ?? invocation.controls.flags ?? EMPTY_EFFECTIVE_FLAGS;
+  return executePreparedInvocation(
+    invocation,
+    aggregation,
+    createProjectContext({
+      ...(preparedChanges === undefined ? {} : { changes: preparedChanges.projectChanges }),
+      flags: effectiveFlags,
+      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 === "terminal-effect") {
+    invocation.outputs.enableTerminalEffects();
+  }
+  invocation.progressRendering.prepared(
+    invocation.normalized.checks.length,
+    invocation.normalized.checks.filter((check) => check.omitQuietPassedRow).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 "terminal-effect":
+      try {
+        await preparedStrategy.completion.terminalEffect(terminalMeasurement);
+        outputs.succeeded("terminalEffects");
+      } catch {
+        outputs.failed("terminalEffects");
+      }
+  }
+}
+
+function isExecutionRunResult(
+  value: SchedulerExecution
+): value is Extract<NonConfigurationRunResult, { readonly kind: "execution" }> {
+  return "declarativeFingerprint" in value;
+}