@kungfu-tech/buildchain 4.0.1-alpha.4 → 4.0.1-alpha.5

package/packages/core/buildchain-contract.js

@@ -7,6 +7,15 @@ import {
   normalizeBuildchainRef,
   parseBuildchainRefIdentity,
 } from "./buildchain-channel-identity.js";
+import {
+  createHistoricalBuildchainCompatibilityFacts,
+  createHistoricalBuildchainCompatibilityProofs,
+} from "./buildchain-compatibility-fact.js";
+import {
+  assertBuildchainCompatibilityProjection,
+  createBuildchainCompatibilityProofRegistry,
+} from "./buildchain-compatibility-authority.js";
+import { evaluateBuildchainContractLock as evaluateFactBackedBuildchainContractLock } from "./buildchain-compatibility-proof.js";
 import { createControllerRegistry } from "./controller-evidence.js";
 import { enumerateWorkflowInputs } from "./public-surface-audit.js";
 import { devDeliveryWorkflowContractSurface } from "./dev-delivery-contract-surface.js";
@@ -18,11 +27,47 @@ export {
   parseBuildchainRefIdentity,
 };
 
+export {
+  BUILDCHAIN_COMPATIBILITY_FACT_REGISTRY_SCHEMA,
+  BUILDCHAIN_COMPATIBILITY_FACT_SCHEMA,
+  BUILDCHAIN_COMPATIBILITY_PROOF_REGISTRY_SCHEMA,
+  BUILDCHAIN_COMPATIBILITY_PROOF_SCHEMA,
+  BUILDCHAIN_COMPATIBILITY_RELEASE_EVIDENCE_SCHEMA,
+  createBuildchainCompatibilityFact,
+  createBuildchainCompatibilityFactRegistry,
+  createBuildchainCompatibilityProof,
+  createHistoricalBuildchainCompatibilityFacts,
+  createHistoricalBuildchainCompatibilityProofs,
+  verifyBuildchainCompatibilityFact,
+  verifyBuildchainCompatibilityFactRegistry,
+  verifyBuildchainCompatibilityProof,
+} from "./buildchain-compatibility-fact.js";
+export {
+  assertBuildchainCompatibilityProjection,
+  createBuildchainCompatibilityPathQuery,
+  createBuildchainCompatibilityProofRegistry,
+  createBuildchainCompatibilityReleaseEvidence,
+  resolveBuildchainCompatibilityProof,
+  verifyBuildchainCompatibilityPath,
+} from "./buildchain-compatibility-authority.js";
+export {
+  BUILDCHAIN_COMPATIBILITY_VERIFICATION_RECEIPT_SCHEMA,
+  BUILDCHAIN_LEGACY_COMPATIBILITY_VERIFICATION_RECEIPT_SCHEMA,
+  createBuildchainCompatibilityVerificationReceipt,
+  verifyBuildchainCompatibilityVerificationReceipt,
+} from "./buildchain-compatibility-proof.js";
+
 export const BUILDCHAIN_RUNTIME_CONTRACT_WORLD = "kungfu-buildchain-runtime-contract-world";
 export const BUILDCHAIN_CONTRACT_LOCK = "kungfu-buildchain-contract-lock";
 
 const DEFAULT_POLICY = "major-compatible";
-const FLOATING_CLASSES = new Set(["stable", "alpha"]);
+
+function compatibilityAuthority() {
+  return {
+    compatibilityFacts: createHistoricalBuildchainCompatibilityFacts(),
+    compatibilityProofs: createHistoricalBuildchainCompatibilityProofs(),
+  };
+}
 
 function optionalString(value) {
   return value === undefined || value === null ? "" : String(value);
@@ -796,26 +841,60 @@ export function createBuildchainContractWorld({
       version: pkg.version || "",
       repository: pkg.repository?.url || pkg.repository || "https://github.com/kungfu-systems/buildchain",
     },
-    majorLine,
-    compatibilityPolicy: DEFAULT_POLICY,
+    majorLine, compatibilityPolicy: DEFAULT_POLICY,
+    ...compatibilityAuthority(),
     surfaces,
   };
   return finalizeBuildchainContractWorld(base);
 }
 
 export function finalizeBuildchainContractWorld(contractWorld) {
+  if (!Array.isArray(contractWorld?.compatibilityFacts) || !Array.isArray(contractWorld?.compatibilityProofs)) {
+    throw new Error("contract world requires compatibility Facts and their proof projection");
+  }
+  const sourceSurfaces = (contractWorld.surfaces || []).map((entry) => ({ ...entry }));
+  const proofRegistry = createBuildchainCompatibilityProofRegistry({
+    proofs: contractWorld.compatibilityProofs,
+    surfaces: sourceSurfaces,
+    majorLine: contractWorld.majorLine,
+  });
+  if (JSON.stringify(contractWorld.compatibilityFacts) !== JSON.stringify(proofRegistry.facts)) {
+    throw new Error("contract world compatibility Facts drift from the verified registry");
+  }
   const world = {
     ...contractWorld,
-    surfaces: (contractWorld.surfaces || []).map((entry) => ({ ...entry })),
+    compatibilityFacts: proofRegistry.facts,
+    compatibilityFactRegistryRoot: proofRegistry.factRegistryRoot,
+    compatibilityFactCutRoot: proofRegistry.factCutRoot,
+    compatibilityProofs: proofRegistry.proofs,
+    compatibilityProofRegistryRoot: proofRegistry.registryRoot,
+    surfaces: sourceSurfaces.map((entry) => {
+      const surfaceEntry = { ...entry };
+      delete surfaceEntry.compatibleBreakingDigests;
+      delete surfaceEntry.compatibilityProofRoots;
+      delete surfaceEntry.compatibilityFactRoots;
+      const projection = proofRegistry.projections[entry.id] || [];
+      if (projection.length > 0) {
+        surfaceEntry.compatibleBreakingDigests = projection.map((item) => item.breakingDigest);
+        surfaceEntry.compatibilityProofRoots = projection.map((item) => item.proofRoot);
+        surfaceEntry.compatibilityFactRoots = projection.map((item) => item.factRoot);
+      }
+      return surfaceEntry;
+    }),
   };
   const compatibilityModel = {
     schemaVersion: world.schemaVersion,
     contract: world.contract,
     majorLine: world.majorLine,
+    compatibilityFactRegistryRoot: world.compatibilityFactRegistryRoot,
+    compatibilityFactCutRoot: world.compatibilityFactCutRoot,
+    compatibilityProofRegistryRoot: world.compatibilityProofRegistryRoot,
     surfaces: world.surfaces.map((entry) => ({
       id: entry.id,
       kind: entry.kind,
       breakingDigest: entry.breakingDigest,
+      compatibilityProofRoots: entry.compatibilityProofRoots || [],
+      compatibilityFactRoots: entry.compatibilityFactRoots || [],
     })),
   };
   const digestModel = {
@@ -847,6 +926,9 @@ export function createBuildchainContractLock({
       contract: contractWorld.contract,
       contractDigest: contractWorld.contractDigest,
       compatibilityDigest: contractWorld.compatibilityDigest,
+      compatibilityFactRegistryRoot: contractWorld.compatibilityFactRegistryRoot,
+      compatibilityFactCutRoot: contractWorld.compatibilityFactCutRoot,
+      compatibilityProofRegistryRoot: contractWorld.compatibilityProofRegistryRoot,
       majorLine: contractWorld.majorLine,
       compatibilityPolicy,
       acceptedAt,
@@ -854,6 +936,8 @@ export function createBuildchainContractLock({
         id: entry.id,
         kind: entry.kind,
         breakingDigest: entry.breakingDigest,
+        compatibilityProofRoots: entry.compatibilityProofRoots || [],
+        compatibilityFactRoots: entry.compatibilityFactRoots || [],
       })),
     },
   };
@@ -890,143 +974,8 @@ export function readBuildchainContractLock(filePath) {
   return value;
 }
 
-function surfaceMap(surfaces = []) {
-  return new Map(surfaces.map((entry) => [entry.id, entry]));
-}
-
-function evaluateChannelBinding({
-  lock,
-  workflowShellRef,
-  runtimeRef,
-  expectedChannel,
-  expectedMajor,
-  allowOpaqueRuntime,
-}) {
-  if (!workflowShellRef && !expectedChannel && !expectedMajor) return null;
-  return evaluateBuildchainChannelBinding({
-    workflowShellRef,
-    runtimeRef,
-    lockRef: lock?.buildchain?.ref || "",
-    lockMajorLine: lock?.buildchain?.majorLine || "",
-    expectedChannel,
-    expectedMajor,
-    allowOpaqueRuntime,
-  });
-}
-
-export function evaluateBuildchainContractLock({
-  lock,
-  current,
-  runtimeRef = "",
-  runtimeSha = "",
-  runtimeClass = "",
-  compatibilityPolicy = "",
-  workflowShellRef = "",
-  expectedChannel = "",
-  expectedMajor = "",
-  allowOpaqueRuntime = false,
-} = {}) {
-  if (!current || current.contract !== BUILDCHAIN_RUNTIME_CONTRACT_WORLD) {
-    throw new Error("current must be a Buildchain runtime contract world");
-  }
-  const binding = evaluateChannelBinding({
-    lock,
-    workflowShellRef,
-    runtimeRef,
-    expectedChannel,
-    expectedMajor,
-    allowOpaqueRuntime,
-  });
-  if (binding?.ok === false) {
-    return {
-      ok: false,
-      status: binding.status,
-      drift: false,
-      compatible: false,
-      issueRecommended: false,
-      reasons: binding.reasons,
-      channelBinding: binding,
-    };
-  }
-  const floatingRuntime = FLOATING_CLASSES.has(runtimeClass);
-  if (!floatingRuntime) {
-    return {
-      ok: true,
-      status: "non-floating-runtime",
-      drift: false,
-      compatible: true,
-      issueRecommended: false,
-      reason: `runtime class ${runtimeClass || "unknown"} is not a stable floating ref`,
-    };
-  }
-  if (!lock) {
-    return {
-      ok: true,
-      status: "missing-lock",
-      drift: false,
-      compatible: true,
-      issueRecommended: false,
-      reason: "consumer repository has no Buildchain contract lock",
-    };
-  }
-  const accepted = lock.buildchain || {};
-  const policy = compatibilityPolicy || accepted.compatibilityPolicy || DEFAULT_POLICY;
-  const shaDrift = !!accepted.resolvedSha && !!runtimeSha && accepted.resolvedSha !== runtimeSha;
-  const contractDrift = !!accepted.contractDigest && accepted.contractDigest !== current.contractDigest;
-  if (!shaDrift && !contractDrift) {
-    return {
-      ok: true,
-      status: "unchanged",
-      drift: false,
-      compatible: true,
-      issueRecommended: false,
-      policy,
-      accepted,
-      current: contractSummary(current, runtimeRef, runtimeSha),
-    };
-  }
-  const reasons = [];
-  if (accepted.contract !== current.contract) {
-    reasons.push(`contract changed from ${accepted.contract || "(unknown)"} to ${current.contract}`);
-  }
-  if (accepted.majorLine && accepted.majorLine !== current.majorLine) {
-    reasons.push(`major line changed from ${accepted.majorLine} to ${current.majorLine}`);
-  }
-  if (policy === "exact" && accepted.contractDigest !== current.contractDigest) {
-    reasons.push("exact policy requires the contract digest to remain unchanged");
-  }
-  if (!["major-compatible", "allow-additive", "exact"].includes(policy)) {
-    reasons.push(`unsupported compatibility policy: ${policy}`);
-  }
-  const currentSurfaces = surfaceMap(current.surfaces);
-  for (const oldSurface of accepted.surfaces || []) {
-    const nextSurface = currentSurfaces.get(oldSurface.id);
-    if (!nextSurface) {
-      reasons.push(`surface removed: ${oldSurface.id}`);
-      continue;
-    }
-    const compatibleBreakingDigests = new Set(nextSurface.compatibleBreakingDigests || []);
-    if (
-      nextSurface.breakingDigest !== oldSurface.breakingDigest
-      && !compatibleBreakingDigests.has(oldSurface.breakingDigest)
-    ) {
-      reasons.push(`surface breaking digest changed: ${oldSurface.id}`);
-    }
-  }
-  const compatible = reasons.length === 0;
-  return {
-    ok: compatible,
-    status: compatible ? "compatible-drift" : "breaking-drift",
-    drift: shaDrift || contractDrift,
-    shaDrift,
-    contractDrift,
-    compatible,
-    issueRecommended: true,
-    policy,
-    reasons,
-    accepted,
-    current: contractSummary(current, runtimeRef, runtimeSha),
-  };
+export function evaluateBuildchainContractLock(options = {}) {
+  return evaluateFactBackedBuildchainContractLock(options);
 }
 
 export function contractSummary(contractWorld, runtimeRef = "", runtimeSha = "") {
@@ -1036,6 +985,9 @@ export function contractSummary(contractWorld, runtimeRef = "", runtimeSha = "")
     contract: contractWorld.contract,
     contractDigest: contractWorld.contractDigest,
     compatibilityDigest: contractWorld.compatibilityDigest,
+    compatibilityFactRegistryRoot: contractWorld.compatibilityFactRegistryRoot,
+    compatibilityFactCutRoot: contractWorld.compatibilityFactCutRoot,
+    compatibilityProofRegistryRoot: contractWorld.compatibilityProofRegistryRoot,
     majorLine: contractWorld.majorLine,
     surfaceCount: Array.isArray(contractWorld.surfaces) ? contractWorld.surfaces.length : 0,
   };

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,
   };
 }

package/packages/core/dev-alpha-candidate-selection.js

@@ -82,7 +82,9 @@ export function selectLatestQualifiedSource({
   requiredWorkflowPaths,
   now,
   maxAgeSeconds,
+  ignoredSourceShas = [],
 }) {
+  const ignored = new Set(ignoredSourceShas);
   const latestByPath = new Map(
     requiredWorkflowPaths.map((workflow) => [
       workflow,
@@ -90,7 +92,11 @@ export function selectLatestQualifiedSource({
     ]),
   );
   for (let index = 0; index < sourceHistory.length; index += 1) {
-    const sourceSha = sourceHistory[index];
+    const sourceSha =
+      typeof sourceHistory[index] === "string"
+        ? sourceHistory[index]
+        : sourceHistory[index]?.sha;
+    if (ignored.has(sourceSha)) continue;
     const rows = requiredWorkflowPaths.map((workflow) =>
       latestByPath.get(workflow).get(sourceSha),
     );
@@ -115,7 +121,9 @@ export function selectLatestQualifiedSource({
       };
     }
   }
-  const staleSuccessfulPair = sourceHistory.some((sourceSha) => {
+  const staleSuccessfulPair = sourceHistory.some((entry) => {
+    const sourceSha = typeof entry === "string" ? entry : entry?.sha;
+    if (ignored.has(sourceSha)) return false;
     const rows = requiredWorkflowPaths.map((workflow) =>
       latestByPath.get(workflow).get(sourceSha),
     );

package/packages/core/dev-delivery-execution-transfer.js

@@ -13,6 +13,7 @@ import {
   devDeliveryText as text,
   devDeliveryTimestamp as timestamp,
 } from "./dev-delivery-common.js";
+import { verifyNativeProofReuseDecision } from "./dev-delivery-native-proof.js";
 import { verifyNativeQualificationProof } from "./dev-delivery-native-proof.js";
 import { verifyNativeExecutionFailureOutcome } from "./dev-delivery-execution-failure.js";
 
@@ -408,8 +409,28 @@ function verifySuccessOutcome(transfer, directory, warrant) {
     "native proof reuse decision root",
   );
   delete decisionBody.decisionRoot;
+  const reuseVerification = verifyNativeProofReuseDecision(decision, {
+    proof,
+    current: {
+      sourceHead: warrant.sourceHead,
+      sourceIdentityRoot: warrant.sourceIdentityRoot,
+      sourcePatchRoot: warrant.sourcePatchRoot,
+      planRoot: warrant.planRoot,
+      closureRoot: warrant.closureRoot,
+      dependencyRoot: warrant.dependencyRoot,
+      toolchainRoot: warrant.toolchainRoot,
+      environmentRoot: warrant.environmentRoot,
+      nativeCommandRoot: warrant.nativeCommandContract?.commandRoot,
+      currentBase: decision.currentBase,
+      graphKnown: decision.graphKnown,
+      attributionComplete: decision.attributionComplete,
+      changedPaths: decision.changedPaths,
+      renames: decision.renames,
+    },
+  });
   if (
     !proofVerification.ok ||
+    !reuseVerification.ok ||
     result.nativeProofRoot !== transfer.nativeProofRoot ||
     proof.proofRoot !== transfer.nativeProofRoot ||
     result.nativeReuseDecisionRoot !== transfer.nativeReuseDecisionRoot ||
@@ -420,7 +441,6 @@ function verifySuccessOutcome(transfer, directory, warrant) {
     proof.repository !== transfer.warrant.repository ||
     proof.protectedBase !== transfer.warrant.protectedBase ||
     proof.sourceHead !== transfer.warrant.sourceHead ||
-    proof.qualifiedBase !== warrant.qualifiedBase ||
     proof.sourceIdentityRoot !== warrant.sourceIdentityRoot ||
     proof.sourcePatchRoot !== warrant.sourcePatchRoot ||
     proof.planRoot !== warrant.planRoot ||

package/packages/core/dev-delivery-process-boundary.js

@@ -30,7 +30,7 @@ const PROVIDER_CREDENTIAL_NAME =
   /(?:^(?:ACTIONS_ID_TOKEN_REQUEST_TOKEN|ACTIONS_RUNTIME_TOKEN|AWS_SESSION_TOKEN|AWS_WEB_IDENTITY_TOKEN_FILE|AZURE_FEDERATED_TOKEN_FILE|GH_TOKEN|GITHUB_TOKEN|GOOGLE_GHA_CREDS_PATH|KUNGFU_GITHUB_TOKEN|NPM_TOKEN|SSH_AUTH_SOCK)$|(?:^|_)(?:(?:api|access|auth|publish|release|provider|promotion|governance|approval|mutation|write)_?(?:key|token)|authorization|credentials?|password|secret|private_key|client_secret|signing_key)(?:_|$))/iu;
 const HOSTED_RUNNER_BOUNDARY = "github-actions-runner-worker/v1";
 const GITHUB_HOSTED_LINUX_WORKER =
-  /^\/home\/runner\/runners\/(\d+\.\d+\.\d+)\/bin\/Runner\.Worker$/u;
+  /^\/home\/runner\/(?:runners|actions-runner\/cached)\/(\d+\.\d+\.\d+)\/bin\/Runner\.Worker$/u;
 function text(value, label) {
   const normalized = normalizedText(value);
   if (!normalized) throw new Error(`${label} is required`);
@@ -61,10 +61,16 @@ function processCredentialNames(procRoot, pid, readFileSync) {
     .split("\0")
     .filter((entry) => {
       const separator = entry.indexOf("=");
+      const name = entry.slice(0, separator);
+      const value = entry.slice(separator + 1);
       return (
         separator > 0 &&
-        Boolean(entry.slice(separator + 1)) &&
-        isCredentialVariableName(entry.slice(0, separator))
+        Boolean(value) &&
+        !(
+          name === "BUILDCHAIN_CREDENTIAL_ANCESTRY_BOUNDARY" &&
+          value === HOSTED_RUNNER_BOUNDARY
+        ) &&
+        isCredentialVariableName(name)
       );
     })
     .map((entry) => entry.slice(0, entry.indexOf("=")));
@@ -108,9 +114,11 @@ function hostedBoundary(procRoot, pid, command, readlinkSync) {
   const executable = ancestryRead(readlinkSync, link);
   if (
     !GITHUB_HOSTED_LINUX_WORKER.test(executable) ||
-    !new Set([executable, path.posix.basename(executable)]).has(command[0])
+    path.posix.basename(command[0]) !== path.posix.basename(executable)
   ) {
-    throw new Error("credential ancestry found an untrusted Runner.Worker");
+    throw new Error(
+      `credential ancestry found an untrusted Runner.Worker: executable=${JSON.stringify(executable)} argv0=${JSON.stringify(command[0])}`,
+    );
   }
   return { pid, kind: HOSTED_RUNNER_BOUNDARY, executable };
 }
@@ -163,7 +171,11 @@ export function assertCredentiallessProcessAncestry(options = {}) {
   return inspection;
 }
 
-export function devDeliveryProviderJobByName(jobs, expectedName) {
+export function devDeliveryProviderJobByName(
+  jobs,
+  expectedName,
+  { allowMissing = false } = {},
+) {
   const exactName = text(expectedName, "provider job name");
   const suffix = ` / ${exactName}`;
   const matches = jobs.filter((job) => {
@@ -173,6 +185,7 @@ export function devDeliveryProviderJobByName(jobs, expectedName) {
       (actualName.endsWith(suffix) && actualName.length > suffix.length)
     );
   });
+  if (matches.length === 0 && allowMissing) return null;
   if (matches.length !== 1) {
     throw new Error(`expected exactly one provider job named ${exactName}`);
   }

package/packages/core/dev-delivery-provider-heartbeat.js

@@ -13,7 +13,7 @@ export const DEV_DELIVERY_PROVIDER_HEARTBEAT_SCHEMA =
   "kungfu.buildchain.provider-heartbeat-receipt/v1";
 
 function selectedWarrant(result = {}) {
-  return result.observation?.activeWarrant || result.warrant || null;
+  return result.warrant || result.observation?.activeWarrant || null;
 }
 
 function exactWarrant(input = {}) {
@@ -40,8 +40,9 @@ function exactWarrant(input = {}) {
   };
 }
 
-function job(entries, name) {
-  const entry = devDeliveryProviderJobByName(entries, name);
+function job(entries, name, options) {
+  const entry = devDeliveryProviderJobByName(entries, name, options);
+  if (!entry) return null;
   const providerJob = {
     id: positiveInteger(entry.id, `${name} job id`),
     name,
@@ -66,13 +67,16 @@ function job(entries, name) {
   return providerJob;
 }
 
-function providerJobs(input, expected) {
+function providerJobs(input, expected, { allowMissingSeal = false } = {}) {
   const entries = Array.isArray(input) ? input : input?.jobs;
   if (!Array.isArray(entries)) {
     throw new Error("provider heartbeat jobs readback must contain jobs");
   }
   const native = job(entries, expected.nativeJobName);
-  const seal = job(entries, expected.sealJobName);
+  const seal = job(entries, expected.sealJobName, {
+    allowMissing: allowMissingSeal,
+  });
+  if (!seal) return null;
   if (native.id === seal.id) {
     throw new Error("provider heartbeat native and seal jobs must be distinct");
   }
@@ -206,7 +210,15 @@ export async function runDevDeliveryProviderHeartbeat(
       const entry = heartbeatEntry(result, previousStateRoot);
       heartbeats.push(entry);
       previousStateRoot = entry.nextStateRoot;
-      jobs = providerJobs(await readJobs(), { nativeJobName, sealJobName });
+      jobs = providerJobs(
+        await readJobs(),
+        { nativeJobName, sealJobName },
+        { allowMissingSeal: true },
+      );
+      if (!jobs) {
+        await wait(cadence * 1000);
+        continue;
+      }
       if (terminal(jobs.native) && terminal(jobs.seal)) break;
       await wait(cadence * 1000);
     }