@kungfu-tech/buildchain 3.0.9-alpha.8 → 4.0.0-alpha.0

package/packages/core/channel-candidate.js

@@ -97,14 +97,6 @@ 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,10 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
 
-import {
-  nextDevelopmentPatrolContext,
-  normalizeNextDevelopmentVersionReservation,
-} from "./next-development-candidate-reservation.js";
-
 const SHA = /^[0-9a-f]{40}$/;
 
 function text(value = "") {
@@ -64,18 +59,6 @@ export function normalizeChannelCandidateSelection(input) {
           ),
         }
       : {}),
-    ...(input.versionReservation
-      ? {
-          versionReservation: normalizeNextDevelopmentVersionReservation(
-            input.versionReservation,
-            {
-              reservationSha: input.versionReservation.reservationSha,
-              candidateSha: input.versionReservation.candidateSha,
-              targetVersion: input.versionReservation.targetVersion,
-            },
-          ),
-        }
-      : {}),
   };
 }
 
@@ -134,7 +117,6 @@ export async function resolvePatrolSourceInputs({
   let comparison = headComparison;
   let workflowEvidence = [];
   let skippedNewerCommitCount = 0;
-  let versionReservation;
   let qualificationError;
   if (
     headComparison.status === "ahead" &&
@@ -148,8 +130,6 @@ export async function resolvePatrolSourceInputs({
       ),
     ]);
     try {
-      const { preparations, ignoredSourceShas } =
-        nextDevelopmentPatrolContext(sourceHistory);
       const selected = selectQualifiedSource({
         sourceHistory,
         workflowRunsByPath: new Map(
@@ -161,39 +141,8 @@ 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) {
@@ -209,7 +158,6 @@ export async function resolvePatrolSourceInputs({
     comparison,
     workflowEvidence,
     skippedNewerCommitCount,
-    versionReservation,
     qualificationError,
   };
 }

package/packages/core/controller-evidence.js

@@ -34,14 +34,13 @@ const CONTROLLER_SPECS = [
       "resolve-runtime",
       "resolve-source",
       "anchored-release-preflight",
-      "pre-build-contracts",
       "build",
       "signing-finalization",
       "credential-island",
       "verify",
       "aggregate",
     ],
-    optionalStages: ["anchored-release-preflight", "pre-build-contracts", "credential-island"],
+    optionalStages: ["anchored-release-preflight", "credential-island"],
     evidence: [
       "platform-manifests",
       "build-summary",
@@ -53,8 +52,8 @@ const CONTROLLER_SPECS = [
     workflowId: "build",
     version: 1,
     capabilities: ["channel-selection", "runtime-selection", "build-delegation"],
-    stages: ["resolve-channel", "alpha", "stable", "aggregate"],
-    optionalStages: ["alpha", "stable"],
+    stages: ["resolve-channel", "override", "alpha", "stable", "aggregate"],
+    optionalStages: ["override", "alpha", "stable"],
     evidence: ["nested-controller-receipt", "controller-receipt"],
   },
   {

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

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

package/packages/core/dev-delivery-warrant-cancellation.js

@@ -6,7 +6,6 @@ const TERMINAL_STATES = new Set(["merged", "terminal-failure", "dequeued", "canc
 const QUEUED_CANCELLATION_EVENTS = new Map([
   ["closed", "cancelled"],
   ["cancelled", "cancelled"],
-  ["synchronize", "cancelled"],
   ["dequeued", "dequeued"],
 ]);
 

package/packages/core/dev-delivery-warrant-settlement.js

@@ -33,11 +33,7 @@ export function createDevDeliveryTerminalSettler({ normalizeQueue, closeWarrant,
     };
     if (!terminalStates.has(identity.outcome)) throw new Error(`outcome must be one of ${[...terminalStates].join(", ")}`);
     const samePullRequest = queue.candidates.filter((entry) => entry.pullRequestNumber === identity.pullRequestNumber);
-    const matchingHead = samePullRequest.filter((entry) => entry.sourceHead === identity.sourceHead);
-    const activeCandidate = queue.activeWarrant
-      ? matchingHead.find((entry) => entry.candidateId === queue.activeWarrant.candidateId)
-      : null;
-    const candidate = activeCandidate || matchingHead.at(-1) || null;
+    const candidate = samePullRequest.find((entry) => entry.sourceHead === identity.sourceHead) || null;
     if (!candidate && samePullRequest.length > 0) throw new Error("terminal event sourceHead does not match the recorded candidate");
 
     if (candidate && terminalStates.has(candidate.status)) {

package/packages/core/dev-delivery-warrant.js

@@ -2,12 +2,10 @@ import { devDeliveryClone as clone, devDeliveryContentRoot, devDeliveryExactRoot
 import { chainedDevDeliveryAttemptInput, createDevDeliveryCandidateIdentity, validateDevDeliveryCandidateChain } from "./dev-delivery-candidate-identity.js";
 import { DEV_DELIVERY_CANCELLATION_RECEIPT_SCHEMA, createCancelQueuedDevDeliveryCandidate } from "./dev-delivery-warrant-cancellation.js";
 import { DEV_DELIVERY_SETTLEMENT_RECEIPT_SCHEMA, createDevDeliveryTerminalSettler } from "./dev-delivery-warrant-settlement.js";
-import { createDevDeliveryWarrantQualifier } from "./dev-delivery-native-proof.js";
 import { compareReleaseBlockerPriority, normalizeReleaseBlockerPriorityClaim } from "./release-blocker-priority.js";
 export { devDeliveryContentRoot } from "./dev-delivery-common.js";
 export { RELEASE_BLOCKER_PRIORITY_CLAIM_SCHEMA, createReleaseBlockerPriorityClaim } from "./release-blocker-priority.js";
 export { SOURCE_QUALIFICATION_PROOF_SCHEMA, PROJECT_CUT_REPLAY_PROOF_SCHEMA, INTEGRATION_DELIVERY_PROOF_SCHEMA, classifyDevDeliveryDelta, createIntegrationDeliveryProof, createProjectCutReplayPlan, createProjectCutReplayProof, createSourceQualificationProof, verifyIntegrationDeliveryProof, verifyProjectCutReplayProof, verifySourceQualificationProof } from "./dev-delivery-proof.js";
-export { DEV_DELIVERY_QUALIFICATION_RECEIPT_SCHEMA, NATIVE_QUALIFICATION_PROOF_SCHEMA, NATIVE_PROOF_REUSE_DECISION_SCHEMA, createNativeProofReuseDecision, createNativeQualificationProof, verifyNativeProofReuseDecision, verifyNativeQualificationProof } from "./dev-delivery-native-proof.js";
 export { DEV_DELIVERY_CANCELLATION_RECEIPT_SCHEMA };
 export const DEV_DELIVERY_QUEUE_CONTRACT = "kungfu-buildchain-dev-delivery-warrant-queue";
 export const DEV_DELIVERY_WARRANT_SCHEMA = "kungfu.buildchain.dev-delivery-warrant/v1";
@@ -61,7 +59,7 @@ function normalizeCandidate(input, expected) {
     throw new Error(`candidateId mismatch for PR #${identity.pullRequestNumber}`);
   }
   const status = text(input.status || "queued");
-  if (!["queued", "selected", "provisional", "proving", "qualified", "waiting", "blocked", ...TERMINAL_STATES].includes(status)) {
+  if (!["queued", "selected", "proving", "waiting", "blocked", ...TERMINAL_STATES].includes(status)) {
     throw new Error(`unsupported candidate status ${status || "<empty>"}`);
   }
   const candidate = {
@@ -73,7 +71,6 @@ function normalizeCandidate(input, expected) {
     closureRoot: exactRoot(input.closureRoot, "closureRoot"),
     dependencyRoot: exactRoot(input.dependencyRoot, "dependencyRoot"),
     toolchainRoot: exactRoot(input.toolchainRoot, "toolchainRoot"),
-    ...(Object.hasOwn(input, "sourceWorkflowRunId") ? { sourceWorkflowRunId: nonNegativeInteger(input.sourceWorkflowRunId, "candidate sourceWorkflowRunId", 0) } : {}),
     priority: priority(input.priority),
     enqueuedAt: timestamp(input.enqueuedAt, "candidate enqueuedAt"),
     updatedAt: timestamp(input.updatedAt || input.enqueuedAt, "candidate updatedAt"),
@@ -82,10 +79,6 @@ function normalizeCandidate(input, expected) {
     status,
     terminal: input.terminal || null,
   };
-  if (Object.hasOwn(input, "affectedPaths")) {
-    if (!Array.isArray(input.affectedPaths)) throw new Error("candidate affectedPaths must be an array");
-    candidate.affectedPaths = [...new Set(input.affectedPaths.map(text).filter(Boolean))].sort();
-  }
   if (Object.hasOwn(input, "releaseBlockerPriority")) candidate.releaseBlockerPriority = normalizeReleaseBlockerPriorityClaim(input.releaseBlockerPriority, candidate, expected);
   return candidate;
 }
@@ -146,20 +139,12 @@ export function normalizeDevDeliveryQueue(input, expected = {}) {
     warrant.generation = positiveInteger(warrant.generation, "Warrant generation");
     warrant.issuedAt = timestamp(warrant.issuedAt, "Warrant issuedAt");
     warrant.expiresAt = timestamp(warrant.expiresAt, "Warrant expiresAt");
-    const warrantPhase = text(warrant.phase || "qualified");
-    if (!["provisional", "qualified"].includes(warrantPhase)) throw new Error("active Warrant phase is unsupported");
-    if (Object.hasOwn(warrant, "phase")) warrant.phase = warrantPhase;
-    if (warrantPhase === "qualified") {
-      if (warrant.nativeProofRoot) warrant.nativeProofRoot = exactRoot(warrant.nativeProofRoot, "Warrant nativeProofRoot");
-      if (warrant.nativeProofReuseRoot) warrant.nativeProofReuseRoot = exactRoot(warrant.nativeProofReuseRoot, "Warrant nativeProofReuseRoot");
-      if (warrant.qualifiedAt) warrant.qualifiedAt = timestamp(warrant.qualifiedAt, "Warrant qualifiedAt");
-    }
-    const activeCandidates = queue.candidates.filter((candidate) => ["selected", "provisional", "proving", "qualified", "waiting", "blocked"].includes(candidate.status));
+    const activeCandidates = queue.candidates.filter((candidate) => ["selected", "proving", "waiting", "blocked"].includes(candidate.status));
     if (activeCandidates.length !== 1 || activeCandidates[0].candidateId !== warrant.candidateId) {
       throw new Error("exactly one active candidate must match the active Warrant");
     }
     if (warrant.releaseBlockerPriority?.claimRoot !== activeCandidates[0].releaseBlockerPriority?.claimRoot) throw new Error("active Warrant release-blocker priority drift");
-  } else if (queue.candidates.some((candidate) => ["selected", "provisional", "proving", "qualified", "waiting", "blocked"].includes(candidate.status))) {
+  } else if (queue.candidates.some((candidate) => ["selected", "proving", "waiting", "blocked"].includes(candidate.status))) {
     throw new Error("active candidate exists without an active Warrant");
   }
   const rooted = withQueueRoot(queue);
@@ -198,7 +183,6 @@ function submissionReceipt({ before, after, candidate, action, now }) {
     closureRoot: candidate.closureRoot,
     dependencyRoot: candidate.dependencyRoot,
     toolchainRoot: candidate.toolchainRoot,
-    ...(Object.hasOwn(candidate, "affectedPaths") ? { affectedPaths: candidate.affectedPaths } : {}),
     sourceWorkflowRunId: candidate.sourceWorkflowRunId,
     ...(Object.hasOwn(candidate, "releaseBlockerPriority") ? { releaseBlockerPriority: candidate.releaseBlockerPriority } : {}),
     deliveryClass: candidate.deliveryClass,
@@ -240,24 +224,17 @@ export function submitDevDeliveryCandidate(queueInput, input, { now = new Date()
           throw new Error(`candidate ${attemptedCandidate.candidateId} is terminal and cannot be resubmitted`);
         }
         const exactProofFields = ["sourcePatchRoot", "sourceProofRoot", "planRoot", "closureRoot", "dependencyRoot", "toolchainRoot"];
-        const exactProofMatches = exactProofFields.every((field) => existing[field] === attemptedCandidate[field]) && JSON.stringify(existing.affectedPaths || []) === JSON.stringify(attemptedCandidate.affectedPaths || []) && existing.releaseBlockerPriority?.claimRoot === attemptedCandidate.releaseBlockerPriority?.claimRoot;
+        const exactProofMatches = exactProofFields.every((field) => existing[field] === attemptedCandidate[field]) && existing.releaseBlockerPriority?.claimRoot === attemptedCandidate.releaseBlockerPriority?.claimRoot;
         if (existing.sourceHead === attemptedCandidate.sourceHead && exactProofMatches) {
           action = "duplicate-noop";
           selected = existing;
         } else {
           if (before.activeWarrant?.candidateId === existing.candidateId) {
-            if (existing.sourceHead !== attemptedCandidate.sourceHead) {
-              throw new Error("selected candidate sourceHead cannot change before terminal Warrant closeout");
-            }
-            action = "active-warrant-retained-noop";
-            selected = existing;
-            return { candidate: selected, action };
+            throw new Error("selected candidate sourceHead cannot change before terminal Warrant closeout");
           }
           const headChanged = existing.sourceHead !== attemptedCandidate.sourceHead;
           existing.sourceHead = attemptedCandidate.sourceHead;
           for (const field of exactProofFields) existing[field] = attemptedCandidate[field];
-          if (Object.hasOwn(attemptedCandidate, "affectedPaths")) existing.affectedPaths = attemptedCandidate.affectedPaths;
-          else delete existing.affectedPaths;
           if (Object.hasOwn(attemptedCandidate, "releaseBlockerPriority")) existing.releaseBlockerPriority = attemptedCandidate.releaseBlockerPriority;
           else delete existing.releaseBlockerPriority;
           existing.updatedAt = currentTime;
@@ -342,7 +319,7 @@ export function selectDevDeliveryWarrant(queueInput, { now = new Date().toISOStr
       candidateId: queue.activeWarrant.candidateId,
       fencingToken: queue.activeWarrant.fencingToken,
       leaseGeneration: queue.activeWarrant.generation,
-      expectedOldStateRoot: recoveryReceipt?.expectedOldStateRoot || queue.stateRoot,
+      expectedOldStateRoot: queue.stateRoot,
       nextStateRoot: queue.stateRoot,
       nextAction: "Continue the active delivery attempt; later candidates remain visibly queued.",
     };
@@ -396,17 +373,15 @@ export function selectDevDeliveryWarrant(queueInput, { now = new Date().toISOStr
         closureRoot: candidate.closureRoot,
         dependencyRoot: candidate.dependencyRoot,
         toolchainRoot: candidate.toolchainRoot,
-        ...(Object.hasOwn(candidate, "affectedPaths") ? { affectedPaths: candidate.affectedPaths } : {}),
         sourceWorkflowRunId: candidate.sourceWorkflowRunId,
         ...(Object.hasOwn(candidate, "releaseBlockerPriority") ? { releaseBlockerPriority: candidate.releaseBlockerPriority } : {}),
         deliveryClass: candidate.deliveryClass,
         generation: next.fencingCounter,
-        phase: "provisional",
         expectedOldStateRoot: before.stateRoot,
         issuedAt,
         expiresAt: new Date(Date.parse(issuedAt) + effectiveLeaseSeconds * 1000).toISOString(),
         fencingToken: "",
-        nextAction: "Run or reuse the exact semantic native proof, then atomically qualify this fenced Warrant.",
+        nextAction: "Replay on the exact current dev base, prove required checks, then enqueue the unchanged PR head.",
       };
       warrant.fencingToken = warrantToken(warrant);
       next.activeWarrant = warrant;
@@ -443,7 +418,7 @@ export function selectDevDeliveryWarrant(queueInput, { now = new Date().toISOStr
     effectivePriority: selected.priority.score,
     fencingToken: transaction.result.warrant.fencingToken,
     leaseGeneration: transaction.result.warrant.generation,
-    expectedOldStateRoot: recoveryReceipt?.expectedOldStateRoot || transaction.expectedOldStateRoot,
+    expectedOldStateRoot: transaction.expectedOldStateRoot,
     nextStateRoot: transaction.after.stateRoot,
     nextAction: transaction.result.warrant.nextAction,
   };
@@ -456,12 +431,12 @@ export function selectDevDeliveryWarrant(queueInput, { now = new Date().toISOStr
   };
 }
 
-function assertWarrantMutation(queue, warrant, now, { allowExpired = false } = {}) {
+function assertWarrantMutation(queue, warrant, now) {
   if (!queue.activeWarrant) throw new Error("no active Delivery Warrant");
   if (text(warrant?.fencingToken) !== queue.activeWarrant.fencingToken) throw new Error("stale fencing token");
   if (Number(warrant?.generation) !== queue.activeWarrant.generation) throw new Error("stale lease generation");
   if (text(warrant?.candidateId) !== queue.activeWarrant.candidateId) throw new Error("Warrant candidate mismatch");
-  if (!allowExpired && Date.parse(queue.activeWarrant.expiresAt) <= Date.parse(now)) throw new Error("Delivery Warrant lease expired");
+  if (Date.parse(queue.activeWarrant.expiresAt) <= Date.parse(now)) throw new Error("Delivery Warrant lease expired");
 }
 
 export function heartbeatDevDeliveryWarrant(queueInput, warrant, { now = new Date().toISOString(), leaseSeconds } = {}) {
@@ -473,7 +448,7 @@ export function heartbeatDevDeliveryWarrant(queueInput, warrant, { now = new Dat
       const effectiveLeaseSeconds = positiveInteger(leaseSeconds, "leaseSeconds", queue.policy.leaseSeconds);
       queue.activeWarrant.expiresAt = new Date(Date.parse(currentTime) + effectiveLeaseSeconds * 1000).toISOString();
       const candidate = queue.candidates.find((entry) => entry.candidateId === queue.activeWarrant.candidateId);
-      candidate.status = queue.activeWarrant.phase === "qualified" ? "qualified" : "proving";
+      candidate.status = "proving";
       candidate.updatedAt = currentTime;
       return { candidate, warrant: queue.activeWarrant };
     },
@@ -497,8 +472,6 @@ export function heartbeatDevDeliveryWarrant(queueInput, warrant, { now = new Dat
   };
 }
 
-const qualifyDevDeliveryWarrantTransition = createDevDeliveryWarrantQualifier({ transition, assertWarrantMutation });
-export function qualifyDevDeliveryWarrant(queueInput, warrant, options) { return qualifyDevDeliveryWarrantTransition(queueInput, warrant, options); }
 export function recoverExpiredDevDeliveryWarrant(queueInput, { now = new Date().toISOString() } = {}) {
   const currentTime = timestamp(now, "now");
   const before = normalizeDevDeliveryQueue(queueInput);
@@ -558,7 +531,7 @@ export function closeDevDeliveryWarrant(queueInput, warrant, { outcome, evidence
   const transaction = transition(
     queueInput,
     (queue, before) => {
-      assertWarrantMutation(before, warrant, currentTime, { allowExpired: true });
+      assertWarrantMutation(before, warrant, currentTime);
       const active = clone(queue.activeWarrant);
       const candidate = queue.candidates.find((entry) => entry.candidateId === active.candidateId);
       candidate.status = normalizedOutcome;
@@ -625,19 +598,6 @@ export function observeDevDeliveryQueue(queueInput, { now = new Date().toISOStri
       queueAgeSeconds: entry.priority.ageSeconds,
       attempts: entry.candidate.attempts,
       recoveries: entry.candidate.recoveries,
-      assignmentRoot: entry.candidate.assignmentRoot,
-      initiativeRoot: entry.candidate.initiativeRoot,
-      sourceIdentityRoot: entry.candidate.sourceIdentityRoot,
-      sourcePatchRoot: entry.candidate.sourcePatchRoot,
-      sourceProofRoot: entry.candidate.sourceProofRoot,
-      planRoot: entry.candidate.planRoot,
-      closureRoot: entry.candidate.closureRoot,
-      dependencyRoot: entry.candidate.dependencyRoot,
-      toolchainRoot: entry.candidate.toolchainRoot,
-      sourceWorkflowRunId: entry.candidate.sourceWorkflowRunId || 0,
-      affectedPaths: entry.candidate.affectedPaths || [],
-      deliveryClass: entry.candidate.deliveryClass,
-      priority: entry.candidate.priority,
       nextAction: index === 0 && !queue.activeWarrant ? "eligible-for-selection" : "wait-for-active-warrant",
     })),
     observedAt: currentTime,

package/packages/core/diagnostics.js

@@ -84,14 +84,10 @@ function fileStats(cwd, entries = []) {
   });
 }
 
-const TOOL_VERSION_PROBE_CWD = path.parse(process.execPath).root;
-
-function commandVersion(command, args = ["--version"]) {
+function commandVersion(command, args = ["--version"], cwd = process.cwd()) {
   try {
     return execFileSync(command, args, {
-      // Package managers may walk every parent even for --version. Keep this
-      // bounded instead of scanning an arbitrary consumer or shared temp root.
-      cwd: TOOL_VERSION_PROBE_CWD,
+      cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 5000,
@@ -497,8 +493,7 @@ export function collectRunnerDiagnostics() {
 }
 
 export function collectToolDiagnostics({ cwd = process.cwd(), tools = ["node", "pnpm", "npm", "git", "cmake", "ninja", "ccache", "sccache"] } = {}) {
-  void cwd;
-  return Object.fromEntries(tools.map((tool) => [tool, { version: commandVersion(tool) }]));
+  return Object.fromEntries(tools.map((tool) => [tool, { version: commandVersion(tool, ["--version"], cwd) }]));
 }
 
 function parseJsonDiagnostics(value = "") {

package/packages/core/github-governance-authority.js

@@ -54,9 +54,11 @@ const PUBLIC_REPOSITORY_TARGETS = Object.freeze({
     target("publish-gate/major", [check("check")], true),
   ],
   buildchain: [
-    target("dev/v3/v3.0", [check("check")], false),
+    ...["v3/v3.0", "v4/v4.0"].map((line) => target(`dev/${line}`, [check("check")], false)),
     target("alpha/v3/v3.0", [check("check"), check("verify")], false),
     target("release/v3/v3.0", [check("check")], true),
+    target("alpha/v4/v4.0", [check("check"), check("verify")], false),
+    target("release/v4/v4.0", [check("check"), check("verify")], true),
     target("authority/v3/v3.0/artifact-signing", [check("check"), check("verify")], true),
     target("publish-gate/major", [check("check")], true),
   ],

package/packages/core/kfd-adopter-category-driver.js

@@ -0,0 +1,167 @@
+import kfdCategoryCatalog from "@kungfu-tech/kfd/adopter-conformance/category-profiles.json" with { type: "json" };
+import kfdPackageJson from "@kungfu-tech/kfd/package.json" with { type: "json" };
+import { resolveAdopterCategoryProfiles } from "@kungfu-tech/kfd/adopter-conformance/category-profile-resolver";
+import { verifyAdopterCategoryInstanceManifest } from "@kungfu-tech/kfd/adopter-conformance/category-instance-verifier";
+import { verifyAdopterManifestFromPackage } from "@kungfu-tech/kfd/adopter-conformance/toolchain";
+
+import {
+  ADOPTER_PROTOCOL_DRIVER_INTERFACE,
+  adopterDeliveryGateDigest,
+  defineAdopterProtocolDriver,
+} from "./adopter-delivery-gate.js";
+
+export const KFD_ADOPTER_CATEGORY_PROTOCOL_ID =
+  "kfd.adopter-category/instance-manifest";
+export const KFD_ADOPTER_CATEGORY_PROTOCOL_VERSION = "1.0.0";
+export const KFD_ADOPTER_CATEGORY_DRIVER_REPORT_CONTRACT =
+  "kungfu-buildchain-kfd-adopter-category-driver-report";
+
+function freezeJson(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) freezeJson(child);
+  }
+  return value;
+}
+
+const publishedCatalog = freezeJson(structuredClone(kfdCategoryCatalog));
+
+function catalogCopy() {
+  return structuredClone(publishedCatalog);
+}
+
+function sameJson(left, right) {
+  try {
+    return adopterDeliveryGateDigest(left) === adopterDeliveryGateDigest(right);
+  } catch {
+    return false;
+  }
+}
+
+function issue(code, path, message) {
+  return { code, path, message };
+}
+
+export function resolvePublishedKfdAdopterCategoryProfiles(selection) {
+  return resolveAdopterCategoryProfiles(
+    structuredClone(selection),
+    catalogCopy(),
+  );
+}
+
+export function verifyPublishedKfdAdopterCategoryInstance(
+  instanceManifest,
+  { adopterManifest, verifiedAt, maxAgeSeconds } = {},
+) {
+  const adopterReport = verifyAdopterManifestFromPackage(adopterManifest, {
+    packageArtifactRoot: instanceManifest?.kfdCut?.packageRoot,
+    verifiedAt,
+    maxAgeSeconds,
+  });
+  return verifyAdopterCategoryInstanceManifest(instanceManifest, {
+    catalog: catalogCopy(),
+    adopterManifest,
+    adopterReport,
+    verifiedAt,
+    maxAgeSeconds,
+  });
+}
+
+function deliveryBindingIssues(request, adopterManifest) {
+  const instance = request.declaration;
+  const issues = [];
+  if (
+    request.project.instanceId !== instance?.instanceId ||
+    request.project.adopterId !== instance?.project?.adopterId
+  ) {
+    issues.push(
+      issue(
+        "delivery-kfd-instance-binding-mismatch",
+        "/project",
+        "Delivery project identity must match the KFD category instance.",
+      ),
+    );
+  }
+  if (!sameJson(request.artifact, instance?.project?.artifact)) {
+    issues.push(
+      issue(
+        "delivery-kfd-instance-binding-mismatch",
+        "/artifact",
+        "Delivery artifact must match the KFD category instance artifact.",
+      ),
+    );
+  }
+  if (
+    adopterManifest?.kfdCut?.package?.name !== kfdPackageJson.name ||
+    adopterManifest?.kfdCut?.package?.version !== kfdPackageJson.version ||
+    instance?.kfdCut?.packageVersion !== kfdPackageJson.version
+  ) {
+    issues.push(
+      issue(
+        "delivery-kfd-package-cut-mismatch",
+        "/declaration/kfdCut",
+        "KFD declarations must bind the exact installed published package version.",
+      ),
+    );
+  }
+  return issues;
+}
+
+function driverReport(categoryReport, adapterIssues) {
+  const valid = categoryReport?.valid === true && adapterIssues.length === 0;
+  const report = {
+    schemaVersion: 1,
+    contract: KFD_ADOPTER_CATEGORY_DRIVER_REPORT_CONTRACT,
+    valid,
+    conforming: valid,
+    qualifying: false,
+    selfCertified: false,
+    independentlyCertified: false,
+    kfdPackage: {
+      name: kfdPackageJson.name,
+      version: kfdPackageJson.version,
+    },
+    categoryReport,
+    adapterIssues,
+    nonClaims: [
+      "Category conformance does not grant runtime permission or release authorization.",
+      "Buildchain carries the published KFD decision and does not certify or reinterpret it.",
+    ],
+  };
+  return {
+    valid,
+    report,
+    reportRoot: adopterDeliveryGateDigest(report),
+    issues: [...(categoryReport?.issues ?? []), ...adapterIssues],
+  };
+}
+
+export function createKfdAdopterCategoryProtocolDriver() {
+  return defineAdopterProtocolDriver({
+    interface: ADOPTER_PROTOCOL_DRIVER_INTERFACE,
+    id: KFD_ADOPTER_CATEGORY_PROTOCOL_ID,
+    version: KFD_ADOPTER_CATEGORY_PROTOCOL_VERSION,
+    verify({ request, context }) {
+      const adapterIssues = deliveryBindingIssues(
+        request,
+        context?.adopterManifest,
+      );
+      let categoryReport = null;
+      try {
+        categoryReport = verifyPublishedKfdAdopterCategoryInstance(
+          request.declaration,
+          context,
+        );
+      } catch {
+        adapterIssues.push(
+          issue(
+            "delivery-kfd-verification-context-invalid",
+            "/protocol",
+            "Published KFD verification could not reproduce from the supplied exact context.",
+          ),
+        );
+      }
+      return driverReport(categoryReport, adapterIssues);
+    },
+  });
+}