@kungfu-tech/buildchain 4.0.1-alpha.2 → 4.0.1-alpha.21

package/packages/core/buildchain-delivery-infrastructure.js

@@ -0,0 +1,164 @@
+import { semanticRoot } from "@kungfu-tech/kfd/scripts/self-conformance-contract.mjs";
+
+import {
+  resolvePublishedKfdAdopterCategoryProfiles,
+  verifyPublishedKfdAdopterCategoryInstance,
+} from "./kfd-adopter-category-driver.js";
+
+export const BUILDCHAIN_DELIVERY_INFRASTRUCTURE_ADOPTER_ID =
+  "kungfu-systems/buildchain";
+export const BUILDCHAIN_DELIVERY_INFRASTRUCTURE_PROFILE = Object.freeze({
+  id: "kfd.adopter-category/delivery-infrastructure",
+  version: "1.0.0",
+});
+
+const CATEGORY_INSTANCE_SCHEMA =
+  "https://kfd.libkungfu.dev/schemas/kfd-adopter-conformance/category-instance-manifest.schema.json";
+const CATEGORY_INSTANCE_CONTRACT = "kfd.adopter-category-instance-manifest/v1";
+const ROOT_PATTERN = /^sha256:[0-9a-f]{64}$/;
+const CLAIM_BOUNDARY = Object.freeze({
+  categoryConformanceIsDeclarationOnly: true,
+  evidenceTransfer: false,
+  runtimePermission: false,
+  releaseAuthorization: false,
+  independentCertification: false,
+  semanticAuthorityTransfer: false,
+});
+
+function exactEvidenceReference(value, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`evidence[${index}] must be an object`);
+  }
+  const fields = ["requirementId", "kind", "coordinate", "root", "observedAt"];
+  const actual = Object.keys(value).sort();
+  const expected = [...fields].sort();
+  if (
+    actual.length !== expected.length ||
+    actual.some((field, fieldIndex) => field !== expected[fieldIndex])
+  ) {
+    throw new TypeError(`evidence[${index}] has an invalid field set`);
+  }
+  for (const field of ["requirementId", "kind", "coordinate", "observedAt"]) {
+    if (typeof value[field] !== "string" || value[field].length === 0) {
+      throw new TypeError(`evidence[${index}].${field} must be non-empty`);
+    }
+  }
+  if (!ROOT_PATTERN.test(value.root ?? "")) {
+    throw new TypeError(`evidence[${index}].root must be a sha256 root`);
+  }
+  return structuredClone(value);
+}
+
+function releaseBound(adopterManifest, artifact, release) {
+  return (adopterManifest?.releaseBindings ?? []).some(
+    (binding) =>
+      semanticRoot(binding.artifact) === semanticRoot(artifact) &&
+      semanticRoot(binding.releasePassport) === semanticRoot(release) &&
+      binding.kfdPackageRoot === adopterManifest.kfdCut.package.artifactRoot,
+  );
+}
+
+export function createBuildchainDeliveryInfrastructureInstanceManifest({
+  instanceId,
+  adopterManifest,
+  source,
+  artifact,
+  release,
+  evidence = [],
+} = {}) {
+  if (typeof instanceId !== "string" || instanceId.length === 0) {
+    throw new TypeError("instanceId must be non-empty");
+  }
+  if (
+    adopterManifest?.adopter?.id !==
+    BUILDCHAIN_DELIVERY_INFRASTRUCTURE_ADOPTER_ID
+  ) {
+    throw new TypeError(
+      `adopterManifest must identify ${BUILDCHAIN_DELIVERY_INFRASTRUCTURE_ADOPTER_ID}`,
+    );
+  }
+  if (!releaseBound(adopterManifest, artifact, release)) {
+    throw new TypeError(
+      "adopterManifest must bind the exact Buildchain artifact and release",
+    );
+  }
+
+  const selection = {
+    schemaVersion: 1,
+    contract: "kfd.adopter-category-profile-selection/v1",
+    profiles: [structuredClone(BUILDCHAIN_DELIVERY_INFRASTRUCTURE_PROFILE)],
+  };
+  const resolution = resolvePublishedKfdAdopterCategoryProfiles(selection);
+  if (!resolution.valid) {
+    throw new Error(
+      `published delivery-infrastructure profile did not resolve: ${JSON.stringify(resolution.issues)}`,
+    );
+  }
+
+  const project = {
+    adopterId: BUILDCHAIN_DELIVERY_INFRASTRUCTURE_ADOPTER_ID,
+    source: structuredClone(source),
+    artifact: structuredClone(artifact),
+    release: structuredClone(release),
+  };
+  const projectRoot = semanticRoot(project);
+  const adopterManifestRoot = semanticRoot(adopterManifest);
+  const packageRoot = adopterManifest.kfdCut.package.artifactRoot;
+  const requirementIds = new Set(
+    resolution.requirements.map((requirement) => requirement.id),
+  );
+  const suppliedEvidence = evidence.map(exactEvidenceReference);
+  for (const [index, entry] of suppliedEvidence.entries()) {
+    if (!requirementIds.has(entry.requirementId)) {
+      throw new TypeError(
+        `evidence[${index}].requirementId is not selected by the published profile`,
+      );
+    }
+  }
+
+  return {
+    $schema: CATEGORY_INSTANCE_SCHEMA,
+    schemaVersion: 1,
+    contract: CATEGORY_INSTANCE_CONTRACT,
+    instanceId,
+    rootAlgorithm: "sha256-kfd-canonical-json-v1",
+    project,
+    adopterManifest: {
+      contract: adopterManifest.contract,
+      manifestId: adopterManifest.manifestId,
+      root: adopterManifestRoot,
+    },
+    kfdCut: {
+      packageVersion: adopterManifest.kfdCut.package.version,
+      packageRoot,
+      categoryCatalogRoot: resolution.catalogRoot,
+    },
+    selection,
+    selectionRoot: resolution.selectionRoot,
+    requirements: resolution.requirements.map((requirement) => ({
+      id: requirement.id,
+      evidence: suppliedEvidence
+        .filter((entry) => entry.requirementId === requirement.id)
+        .map(({ requirementId: _requirementId, ...entry }) => ({
+          ...entry,
+          projectInstanceId: instanceId,
+          projectRoot,
+          adopterManifestRoot,
+          kfdPackageRoot: packageRoot,
+          categorySelectionRoot: resolution.selectionRoot,
+        })),
+    })),
+    claimBoundary: structuredClone(CLAIM_BOUNDARY),
+  };
+}
+
+export function verifyBuildchainDeliveryInfrastructureInstance(
+  manifest,
+  { adopterManifest, verifiedAt, maxAgeSeconds } = {},
+) {
+  return verifyPublishedKfdAdopterCategoryInstance(manifest, {
+    adopterManifest,
+    verifiedAt,
+    maxAgeSeconds,
+  });
+}

package/packages/core/buildchain-delivery-self-dogfood.js

@@ -0,0 +1,395 @@
+import { initAdopterManifest } from "@kungfu-tech/kfd/adopter-conformance/toolchain";
+
+import { adopterDeliveryGateDigest } from "./adopter-delivery-gate.js";
+import { withPublishedBuildchainDeliveryAuthority } from "./published-delivery-authority.js";
+
+export const BUILDCHAIN_DELIVERY_SELF_DOGFOOD_CONTRACT =
+  "kungfu-buildchain-delivery-infrastructure-self-dogfood/v1";
+
+const ROOT_PATTERN = /^sha256:[0-9a-f]{64}$/;
+const SHA_PATTERN = /^[0-9a-f]{40}$/;
+const BUILDCHAIN_PACKAGE = "@kungfu-tech/buildchain";
+const KFD_PACKAGE = "@kungfu-tech/kfd";
+const PROFILE_REQUIREMENTS = Object.freeze([
+  ["adopter-identity", ["declaration"]],
+  ["artifact-readback", ["verification"]],
+  ["claim-boundary", ["declaration"]],
+  ["delivery-policy-cut", ["declaration", "verification"]],
+  ["kfd-cut", ["verification"]],
+  ["protected-delivery", ["implementation", "review", "verification"]],
+  ["source-artifact", ["implementation"]],
+]);
+
+function exactPackage(value, { name, version = "", root = "", label }) {
+  if (
+    value?.name !== name ||
+    typeof value.version !== "string" ||
+    value.version.length === 0 ||
+    !ROOT_PATTERN.test(value.artifactRoot ?? "")
+  ) {
+    throw new TypeError(`${label} package identity is incomplete`);
+  }
+  if (version && value.version !== version) {
+    throw new TypeError(`${label} package version does not match its binding`);
+  }
+  if (root && value.artifactRoot !== root) {
+    throw new TypeError(`${label} package root does not match its binding`);
+  }
+  return structuredClone(value);
+}
+
+function authorityFunctions(authorityRuntime) {
+  const names = [
+    "createBuildchainDeliveryInfrastructureInstanceManifest",
+    "verifyBuildchainDeliveryInfrastructureInstance",
+    "createAdopterDeliveryGate",
+    "createPackageArtifactProfile",
+    "createKfdAdopterCategoryProtocolDriver",
+    "qualifyBuildchainDeliveryInfrastructureBootstrap",
+  ];
+  for (const name of names) {
+    if (typeof authorityRuntime?.[name] !== "function") {
+      throw new TypeError(`authority runtime is missing ${name}`);
+    }
+  }
+  return authorityRuntime;
+}
+
+function passed(value, label) {
+  if (value?.status !== "passed") {
+    throw new Error(
+      `${label} failed closed: ${JSON.stringify(value?.issues ?? [])}`,
+    );
+  }
+  return value;
+}
+
+function candidateWarrant(candidate) {
+  const terminal = candidate?.terminal;
+  if (
+    candidate?.status !== "merged" ||
+    !SHA_PATTERN.test(candidate?.sourceHead ?? "") ||
+    !ROOT_PATTERN.test(candidate?.sourceProofRoot ?? "") ||
+    terminal?.outcome !== "merged" ||
+    !ROOT_PATTERN.test(terminal?.nativeProofRoot ?? "") ||
+    !ROOT_PATTERN.test(terminal?.evidenceRoot ?? "")
+  ) {
+    throw new TypeError("candidate Warrant settlement is incomplete");
+  }
+  return {
+    outcome: "merged",
+    sourceHead: candidate.sourceHead,
+    sourceProofRoot: candidate.sourceProofRoot,
+    nativeProofRoot: terminal.nativeProofRoot,
+    integrationProofRoot: terminal.evidenceRoot,
+  };
+}
+
+function deliveryCut() {
+  const protocol = {
+    id: "kfd.adopter-category/instance-manifest",
+    version: "1.0.0",
+  };
+  protocol.root = adopterDeliveryGateDigest(protocol);
+  const profile = {
+    id: "kfd.adopter-category/delivery-infrastructure",
+    version: "1.0.0",
+  };
+  profile.root = adopterDeliveryGateDigest({
+    ...profile,
+    requirements: PROFILE_REQUIREMENTS,
+  });
+  return {
+    gateRoot: adopterDeliveryGateDigest({
+      protocol,
+      profile,
+      artifactProfile: {
+        id: "buildchain.artifact/package",
+        version: "1.0.0",
+      },
+    }),
+    protocol,
+    profile,
+  };
+}
+
+function candidateEvidence({
+  source,
+  artifact,
+  authority,
+  warrant,
+  kfdRoot,
+  observedAt,
+}) {
+  const roots = {
+    "adopter-identity:declaration": source.root,
+    "artifact-readback:verification": artifact.root,
+    "claim-boundary:declaration": adopterDeliveryGateDigest({
+      qualifying: false,
+      selfCertified: false,
+      releaseAuthorized: false,
+    }),
+    "delivery-policy-cut:declaration": authority.gateRoot,
+    "delivery-policy-cut:verification": warrant.integrationProofRoot,
+    "kfd-cut:verification": kfdRoot,
+    "protected-delivery:implementation": artifact.root,
+    "protected-delivery:review": warrant.sourceProofRoot,
+    "protected-delivery:verification": warrant.nativeProofRoot,
+    "source-artifact:implementation": source.root,
+  };
+  return PROFILE_REQUIREMENTS.flatMap(([requirementId, kinds]) =>
+    kinds.map((kind) => ({
+      requirementId,
+      kind,
+      coordinate: `evidence://kungfu-systems/buildchain/${requirementId}/${kind}`,
+      root: roots[`${requirementId}:${kind}`],
+      observedAt,
+    })),
+  );
+}
+
+export function createBuildchainDeliveryInfrastructureSelfDogfood(
+  {
+    authorityPackage,
+    kfdPackage,
+    authority,
+    candidate,
+    instanceId,
+    adopterManifest,
+    source,
+    artifact,
+    release,
+    evidence = [],
+    warrant,
+    transitionEvidence,
+    verifiedAt,
+    maxAgeSeconds,
+  } = {},
+  authorityRuntime,
+) {
+  const runtime = authorityFunctions(authorityRuntime);
+  const boundAuthorityPackage = exactPackage(authorityPackage, {
+    name: BUILDCHAIN_PACKAGE,
+    version: authority?.version,
+    root: authority?.packageRoot,
+    label: "Buildchain authority",
+  });
+  const boundKfdPackage = exactPackage(kfdPackage, {
+    name: KFD_PACKAGE,
+    version: adopterManifest?.kfdCut?.package?.version,
+    root: adopterManifest?.kfdCut?.package?.artifactRoot,
+    label: "KFD authority",
+  });
+  if (candidate?.authorityVersion !== boundAuthorityPackage.version) {
+    throw new TypeError(
+      "candidate does not name the exact Buildchain N-1 authority",
+    );
+  }
+
+  const instanceManifest =
+    runtime.createBuildchainDeliveryInfrastructureInstanceManifest({
+      instanceId,
+      adopterManifest,
+      source,
+      artifact,
+      release,
+      evidence,
+    });
+  const instanceReport = runtime.verifyBuildchainDeliveryInfrastructureInstance(
+    instanceManifest,
+    {
+      adopterManifest,
+      verifiedAt,
+      maxAgeSeconds,
+    },
+  );
+  if (instanceReport?.valid !== true) {
+    throw new Error(
+      `delivery-infrastructure instance failed closed: ${JSON.stringify(instanceReport?.issues ?? [])}`,
+    );
+  }
+
+  const gateResult = passed(
+    runtime
+      .createAdopterDeliveryGate({
+        drivers: [runtime.createKfdAdopterCategoryProtocolDriver()],
+        artifactProfiles: [runtime.createPackageArtifactProfile()],
+      })
+      .evaluate(
+        {
+          schemaVersion: 1,
+          contract: "kungfu-buildchain-adopter-delivery-request",
+          protocol: {
+            id: "kfd.adopter-category/instance-manifest",
+            version: "1.0.0",
+          },
+          artifactProfile: {
+            id: "buildchain.artifact/package",
+            version: "1.0.0",
+          },
+          project: {
+            instanceId,
+            adopterId: "kungfu-systems/buildchain",
+          },
+          artifact: structuredClone(artifact),
+          declaration: instanceManifest,
+        },
+        { adopterManifest, verifiedAt, maxAgeSeconds },
+      ),
+    "adopter delivery gate",
+  );
+  const bootstrap = passed(
+    runtime.qualifyBuildchainDeliveryInfrastructureBootstrap({
+      authority,
+      candidate,
+      gateResult,
+      warrant,
+      transitionEvidence,
+    }),
+    "delivery-infrastructure bootstrap",
+  );
+
+  const result = {
+    schemaVersion: 1,
+    contract: BUILDCHAIN_DELIVERY_SELF_DOGFOOD_CONTRACT,
+    status: "passed",
+    authorityRuntime: {
+      buildchainPackage: boundAuthorityPackage,
+      kfdPackage: boundKfdPackage,
+    },
+    candidate: structuredClone(candidate),
+    roots: {
+      adopterManifest: adopterDeliveryGateDigest(adopterManifest),
+      instanceManifest: adopterDeliveryGateDigest(instanceManifest),
+      instanceReport: adopterDeliveryGateDigest(instanceReport),
+      gateResult: gateResult.gateRoot,
+      bootstrap: bootstrap.bootstrapRoot,
+      warrant: adopterDeliveryGateDigest(warrant),
+    },
+    instanceManifest,
+    instanceReport,
+    gateResult,
+    bootstrap,
+    qualifying: false,
+    selfCertified: false,
+    releaseAuthorized: false,
+    finalAuthority:
+      "protected-n-minus-one-runtime-plus-exact-delivery-evidence",
+  };
+  result.selfDogfoodRoot = adopterDeliveryGateDigest(result);
+  return result;
+}
+
+export async function createPublishedBuildchainDeliveryInfrastructureSelfDogfood({
+  authorityPackages,
+  selfDogfood,
+} = {}) {
+  return withPublishedBuildchainDeliveryAuthority(
+    authorityPackages,
+    async ({ packages, authorityRuntime, authorityRoot }) => {
+      const result = createBuildchainDeliveryInfrastructureSelfDogfood(
+        {
+          ...structuredClone(selfDogfood ?? {}),
+          authorityPackage: packages.buildchain,
+          kfdPackage: packages.kfd,
+        },
+        authorityRuntime,
+      );
+      return {
+        ...result,
+        publishedAuthorityRoot: authorityRoot,
+      };
+    },
+  );
+}
+
+export async function createPublishedBuildchainDeliveryInfrastructureCandidateSelfDogfood({
+  authorityPackages,
+  authoritySourceCommit,
+  candidatePackage,
+  warrantCandidate,
+  source,
+  release,
+  verifiedAt,
+  maxAgeSeconds = 86400,
+} = {}) {
+  if (!SHA_PATTERN.test(authoritySourceCommit ?? "")) {
+    throw new TypeError("authority source commit is invalid");
+  }
+  const artifact = exactPackage(candidatePackage, {
+    name: BUILDCHAIN_PACKAGE,
+    label: "Buildchain candidate",
+  });
+  if (
+    source?.coordinate !==
+      `kungfu-systems/buildchain@${warrantCandidate?.sourceHead ?? ""}` ||
+    !ROOT_PATTERN.test(source?.root ?? "") ||
+    !ROOT_PATTERN.test(release?.root ?? "")
+  ) {
+    throw new TypeError("candidate source or release binding is incomplete");
+  }
+  const warrant = candidateWarrant(warrantCandidate);
+  const cut = deliveryCut();
+  const authority = {
+    version: authorityPackages?.buildchain?.version,
+    sourceCommit: authoritySourceCommit,
+    packageRoot: authorityPackages?.buildchain?.artifactRoot,
+    ...cut,
+    protected: true,
+    published: true,
+  };
+  const candidate = {
+    version: artifact.version,
+    sourceCommit: warrant.sourceHead,
+    packageRoot: artifact.artifactRoot,
+    ...cut,
+    authorityVersion: authority.version,
+  };
+  const adopterManifest = initAdopterManifest({
+    manifestId: `buildchain-delivery-infrastructure-${artifact.version}`,
+    adopterId: "kungfu-systems/buildchain",
+    artifactKind: "package",
+    artifactCoordinate: `${artifact.name}@${artifact.version}`,
+    artifactRoot: artifact.artifactRoot,
+    scope: "Buildchain delivery infrastructure release candidate self-dogfood",
+    packageArtifactRoot: authorityPackages?.kfd?.artifactRoot,
+    verifiedAt,
+    maxAgeSeconds,
+  });
+  adopterManifest.releaseBindings.push({
+    id: `buildchain-${artifact.version}`,
+    artifact: {
+      kind: "package",
+      coordinate: `${artifact.name}@${artifact.version}`,
+      root: artifact.artifactRoot,
+    },
+    releasePassport: structuredClone(release),
+    kfdPackageRoot: authorityPackages.kfd.artifactRoot,
+  });
+  const evidence = candidateEvidence({
+    source,
+    artifact: adopterManifest.releaseBindings[0].artifact,
+    authority,
+    warrant,
+    kfdRoot: authorityPackages.kfd.artifactRoot,
+    observedAt: verifiedAt,
+  });
+  const result =
+    await createPublishedBuildchainDeliveryInfrastructureSelfDogfood({
+      authorityPackages,
+      selfDogfood: {
+        authority,
+        candidate,
+        instanceId: `kungfu-systems/buildchain@${artifact.version}`,
+        adopterManifest,
+        source,
+        artifact: adopterManifest.releaseBindings[0].artifact,
+        release,
+        evidence,
+        warrant,
+        verifiedAt,
+        maxAgeSeconds,
+      },
+    });
+  return { ...result, adopterManifest, deliveryEvidence: evidence };
+}

package/packages/core/buildchain-publication-authority.js

@@ -29,6 +29,7 @@ const DESCRIPTORS = Object.freeze([
   [".github/workflows/buildchain-patrol-monthly.yml", "governance-write"],
   [".github/workflows/buildchain-patrol-weekly.yml", "governance-write"],
   [".github/workflows/buildchain-patrol.yml", "governance-write"],
+  [".github/workflows/buildchain-ref-promotion-recovery.yml", "governance-write"],
   [".github/workflows/buildchain-ref-promotion.yml", "governance-write"],
   [".github/workflows/buildchain-stable-candidate-patrol.yml", "governance-write"],
   [".github/workflows/dev-qualification-patrol.yml", "governance-write"],

package/packages/core/channel-candidate.js

@@ -97,6 +97,14 @@ export function decideChannelCandidate(input) {
   const sourceSha = sha(input.sourceSha, "sourceSha");
   const targetSha = sha(input.targetSha, "targetSha");
   const selection = normalizeChannelCandidateSelection(input.selection);
+  if (
+    selection?.versionReservation &&
+    selection.versionReservation.candidateSha !== sourceSha
+  ) {
+    throw new Error(
+      "selection version reservation must bind the selected source SHA",
+    );
+  }
   const now = required(input.now || new Date().toISOString(), "now");
   const maxAgeSeconds = Number(input.maxAgeSeconds ?? 7 * 24 * 60 * 60);
   if (!Number.isSafeInteger(maxAgeSeconds) || maxAgeSeconds <= 0) {

package/packages/core/channel-promotion-baseline.js

@@ -1,5 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
+import {
+  nextDevelopmentPatrolContext,
+  normalizeNextDevelopmentVersionReservation,
+} from "./next-development-candidate-reservation.js";
+
 const SHA = /^[0-9a-f]{40}$/;
 
 function text(value = "") {
@@ -59,6 +64,18 @@ export function normalizeChannelCandidateSelection(input) {
           ),
         }
       : {}),
+    ...(input.versionReservation
+      ? {
+          versionReservation: normalizeNextDevelopmentVersionReservation(
+            input.versionReservation,
+            {
+              reservationSha: input.versionReservation.reservationSha,
+              candidateSha: input.versionReservation.candidateSha,
+              targetVersion: input.versionReservation.targetVersion,
+            },
+          ),
+        }
+      : {}),
   };
 }
 
@@ -117,6 +134,7 @@ export async function resolvePatrolSourceInputs({
   let comparison = headComparison;
   let workflowEvidence = [];
   let skippedNewerCommitCount = 0;
+  let versionReservation;
   let qualificationError;
   if (
     headComparison.status === "ahead" &&
@@ -130,6 +148,8 @@ export async function resolvePatrolSourceInputs({
       ),
     ]);
     try {
+      const { preparations, ignoredSourceShas } =
+        nextDevelopmentPatrolContext(sourceHistory);
       const selected = selectQualifiedSource({
         sourceHistory,
         workflowRunsByPath: new Map(
@@ -141,8 +161,42 @@ export async function resolvePatrolSourceInputs({
         requiredWorkflowPaths,
         now: options.now,
         maxAgeSeconds: options.maxAgeSeconds,
+        ignoredSourceShas,
       });
       ({ sourceSha, skippedNewerCommitCount, workflowEvidence } = selected);
+      const selectedIndex = sourceHistory.findIndex(
+        (entry) =>
+          (typeof entry === "string" ? entry : entry?.sha) === sourceSha,
+      );
+      const reservation = preparations.find(
+        ({ index }) => index > selectedIndex,
+      )?.preparation;
+      if (reservation) {
+        if (
+          typeof client.readNextDevelopmentVersionReservation !== "function"
+        ) {
+          throw new Error(
+            "candidate follows next-development preparation but reservation readback is unavailable",
+          );
+        }
+        versionReservation = normalizeNextDevelopmentVersionReservation(
+          await client.readNextDevelopmentVersionReservation({
+            reservationSha: reservation.sha,
+            candidateSha: sourceSha,
+            targetVersion: reservation.targetVersion,
+          }),
+          {
+            reservationSha: reservation.sha,
+            candidateSha: sourceSha,
+            targetVersion: reservation.targetVersion,
+          },
+        );
+        if (versionReservation.status !== "current") {
+          throw new Error(
+            `next-development version reservation is ${versionReservation.status} for candidate ${sourceSha}`,
+          );
+        }
+      }
       if (sourceSha !== observedSourceHeadSha)
         comparison = await client.compare(boundarySha, sourceSha);
     } catch (error) {
@@ -158,6 +212,7 @@ export async function resolvePatrolSourceInputs({
     comparison,
     workflowEvidence,
     skippedNewerCommitCount,
+    versionReservation,
     qualificationError,
   };
 }