@kungfu-tech/buildchain 4.0.1-alpha.9 → 4.0.2-alpha.0

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

@@ -1,13 +1,18 @@
 import {
+  devDeliveryClone as clone,
   devDeliveryContentRoot,
   devDeliveryExactRoot as exactRoot,
   devDeliveryExactSha as exactSha,
   devDeliveryPositiveInteger as positiveInteger,
   devDeliveryText as text,
+  devDeliveryTimestamp as timestamp,
 } from "./dev-delivery-common.js";
+import { verifyIntegrationDeliveryProof } from "./dev-delivery-proof.js";
 
 export const DEV_DELIVERY_SETTLEMENT_RECEIPT_SCHEMA =
   "kungfu.buildchain.dev-delivery-settlement-receipt/v1";
+export const DEV_DELIVERY_TERMINAL_EVIDENCE_CORRECTION_SCHEMA =
+  "kungfu.buildchain.dev-delivery-terminal-evidence-correction/v1";
 
 const PROVIDER_FAILURE_FIELDS = [
   "transferRoot",
@@ -16,6 +21,233 @@ const PROVIDER_FAILURE_FIELDS = [
   "sealJobId",
 ];
 
+function correctionBody(input) {
+  const body = clone(input || {});
+  delete body.correctionRoot;
+  return body;
+}
+
+export function normalizeTerminalEvidenceCorrection(
+  input,
+  { candidate, repository, protectedBase } = {},
+) {
+  const correction = correctionBody(input);
+  if (correction.schema !== DEV_DELIVERY_TERMINAL_EVIDENCE_CORRECTION_SCHEMA) {
+    throw new Error("unsupported terminal evidence correction schema");
+  }
+  correction.candidateId = exactRoot(
+    correction.candidateId,
+    "terminal evidence correction candidateId",
+  );
+  correction.pullRequestNumber = positiveInteger(
+    correction.pullRequestNumber,
+    "terminal evidence correction pullRequestNumber",
+  );
+  correction.sourceHead = exactSha(
+    correction.sourceHead,
+    "terminal evidence correction sourceHead",
+  );
+  correction.outcome = text(correction.outcome);
+  correction.priorEvidenceRoot = exactRoot(
+    correction.priorEvidenceRoot,
+    "terminal evidence correction priorEvidenceRoot",
+  );
+  correction.correctedAt = timestamp(
+    correction.correctedAt,
+    "terminal evidence correction correctedAt",
+  );
+  correction.reason = text(correction.reason);
+  if (!correction.reason) {
+    throw new Error("terminal evidence correction reason is required");
+  }
+  const verification = verifyIntegrationDeliveryProof(
+    correction.integrationProof,
+  );
+  if (!verification.ok) {
+    throw new Error(
+      `terminal evidence correction requires an exact integration proof: ${verification.reason}`,
+    );
+  }
+  if (
+    correction.integrationProof.currentBase !==
+      correction.integrationProof.mergeGroupHead ||
+    correction.integrationProof.replayTree !==
+      correction.integrationProof.mergeGroupTree
+  ) {
+    throw new Error(
+      "terminal evidence correction requires exact merge-group commit and tree continuity",
+    );
+  }
+  if (candidate) {
+    const checks = {
+      candidateId: correction.candidateId === candidate.candidateId,
+      pullRequestNumber:
+        correction.pullRequestNumber === candidate.pullRequestNumber,
+      sourceHead: correction.sourceHead === candidate.sourceHead,
+      outcome:
+        correction.outcome === candidate.status &&
+        correction.outcome === candidate.terminal?.outcome,
+      priorEvidenceRoot:
+        correction.priorEvidenceRoot === candidate.terminal?.evidenceRoot,
+      repository: correction.integrationProof.repository === repository,
+      protectedBase:
+        correction.integrationProof.protectedBase === protectedBase,
+      sourceProofRoot:
+        correction.integrationProof.sourceProofRoot ===
+        candidate.sourceProofRoot,
+      warrantCandidateId:
+        correction.integrationProof.warrantCandidateId ===
+        candidate.candidateId,
+      warrantFencingToken:
+        correction.integrationProof.warrantFencingToken ===
+        candidate.terminal?.fencingToken,
+      warrantGeneration:
+        correction.integrationProof.warrantGeneration ===
+        candidate.terminal?.leaseGeneration,
+    };
+    const failed = Object.entries(checks)
+      .filter(([, matches]) => !matches)
+      .map(([field]) => field);
+    if (failed.length > 0) {
+      throw new Error(
+        `terminal evidence correction identity drift: ${failed.join(", ")}`,
+      );
+    }
+  }
+  const correctionRoot = devDeliveryContentRoot(correction);
+  if (input?.correctionRoot && input.correctionRoot !== correctionRoot) {
+    throw new Error("terminal evidence correction root drift");
+  }
+  return { ...correction, correctionRoot };
+}
+
+export function effectiveTerminalEvidenceRoot(candidate) {
+  return (
+    candidate?.terminal?.integrationEvidenceCorrection?.integrationProof
+      ?.proofRoot ||
+    candidate?.terminal?.evidenceRoot ||
+    ""
+  );
+}
+
+export function createTerminalEvidenceCorrection(
+  candidate,
+  input,
+  { repository, protectedBase, now } = {},
+) {
+  return normalizeTerminalEvidenceCorrection(
+    {
+      schema: DEV_DELIVERY_TERMINAL_EVIDENCE_CORRECTION_SCHEMA,
+      candidateId: candidate?.candidateId,
+      pullRequestNumber: candidate?.pullRequestNumber,
+      sourceHead: candidate?.sourceHead,
+      outcome: candidate?.status,
+      priorEvidenceRoot: input?.expectedPriorEvidenceRoot,
+      integrationProof: input?.integrationProof,
+      correctedAt: now,
+      reason: input?.reason,
+    },
+    { candidate, repository, protectedBase },
+  );
+}
+
+export function createDevDeliveryTerminalEvidenceReconciler({
+  normalizeQueue,
+  transition,
+}) {
+  return function reconcileDevDeliveryTerminalEvidence(
+    queueInput,
+    input,
+    { now = new Date().toISOString() } = {},
+  ) {
+    const before = normalizeQueue(queueInput);
+    const candidate = before.candidates.find(
+      (entry) =>
+        entry.candidateId === exactRoot(input?.candidateId, "candidateId"),
+    );
+    if (!candidate)
+      throw new Error("terminal evidence candidate does not exist");
+    if (candidate.status !== "merged") {
+      throw new Error(
+        "integration evidence correction requires a merged candidate",
+      );
+    }
+    const existing = candidate.terminal?.integrationEvidenceCorrection;
+    const correction = createTerminalEvidenceCorrection(candidate, input, {
+      repository: before.repository,
+      protectedBase: before.protectedBase,
+      now: existing?.correctedAt || timestamp(now, "now"),
+    });
+    if (existing) {
+      if (existing.correctionRoot !== correction.correctionRoot) {
+        throw new Error(
+          "terminal evidence correction already exists with different evidence",
+        );
+      }
+      const receipt = {
+        schema: DEV_DELIVERY_SETTLEMENT_RECEIPT_SCHEMA,
+        action: "duplicate-terminal-evidence-correction-noop",
+        applicable: true,
+        repository: before.repository,
+        protectedBase: before.protectedBase,
+        candidateId: candidate.candidateId,
+        pullRequestNumber: candidate.pullRequestNumber,
+        sourceHead: candidate.sourceHead,
+        outcome: candidate.status,
+        priorEvidenceRoot: candidate.terminal.evidenceRoot,
+        evidenceRoot: correction.integrationProof.proofRoot,
+        correctionRoot: correction.correctionRoot,
+        expectedOldStateRoot: before.stateRoot,
+        nextStateRoot: before.stateRoot,
+        nextAction:
+          "Retain the exact verified integration evidence correction.",
+      };
+      return {
+        queue: before,
+        receipt,
+        receiptRoot: devDeliveryContentRoot(receipt),
+      };
+    }
+    const transaction = transition(
+      before,
+      (queue) => {
+        const mutable = queue.candidates.find(
+          (entry) => entry.candidateId === candidate.candidateId,
+        );
+        mutable.terminal = {
+          ...mutable.terminal,
+          integrationEvidenceCorrection: correction,
+        };
+        return { candidate: mutable };
+      },
+      correction.correctedAt,
+    );
+    const receipt = {
+      schema: DEV_DELIVERY_SETTLEMENT_RECEIPT_SCHEMA,
+      action: "terminal-evidence-corrected",
+      applicable: true,
+      repository: transaction.after.repository,
+      protectedBase: transaction.after.protectedBase,
+      candidateId: candidate.candidateId,
+      pullRequestNumber: candidate.pullRequestNumber,
+      sourceHead: candidate.sourceHead,
+      outcome: candidate.status,
+      priorEvidenceRoot: candidate.terminal.evidenceRoot,
+      evidenceRoot: correction.integrationProof.proofRoot,
+      correctionRoot: correction.correctionRoot,
+      expectedOldStateRoot: transaction.expectedOldStateRoot,
+      nextStateRoot: transaction.after.stateRoot,
+      nextAction:
+        "Read back the corrected terminal candidate and repeat settlement idempotently.",
+    };
+    return {
+      queue: transaction.after,
+      receipt,
+      receiptRoot: devDeliveryContentRoot(receipt),
+    };
+  };
+}
+
 export function normalizeProviderFailureAuthorityBinding(
   input = {},
   { required = false } = {},
@@ -56,7 +288,7 @@ function noopReceipt(queue, identity, candidate, action, details = {}) {
     outcome: identity.outcome,
     candidateId: candidate?.candidateId || null,
     evidenceRoot:
-      candidate?.terminal?.evidenceRoot || identity.evidenceRoot || null,
+      effectiveTerminalEvidenceRoot(candidate) || identity.evidenceRoot || null,
     expectedOldStateRoot: queue.stateRoot,
     nextStateRoot: queue.stateRoot,
     nextAction: "No fenced delivery state remains for this terminal event.",
@@ -95,7 +327,7 @@ function settleTerminalCandidate(queue, identity, candidate) {
       "duplicate terminal event provider failure authority drift",
     );
   }
-  if (candidate.terminal?.evidenceRoot !== identity.evidenceRoot) {
+  if (effectiveTerminalEvidenceRoot(candidate) !== identity.evidenceRoot) {
     throw new Error("duplicate terminal event evidenceRoot drift");
   }
   const receipt = noopReceipt(
@@ -103,6 +335,7 @@ function settleTerminalCandidate(queue, identity, candidate) {
     identity,
     candidate,
     "duplicate-terminal-event-noop",
+    { successorWake: candidate.terminal?.successorWake || null },
   );
   return { queue, receipt, receiptRoot: devDeliveryContentRoot(receipt) };
 }
@@ -207,7 +440,10 @@ export function createDevDeliveryTerminalSettler({
         throw new Error("stale fencing token");
       if (leaseGeneration !== queue.activeWarrant.generation)
         throw new Error("stale lease generation");
-      if (identity.outcome === "dequeued") {
+      if (
+        identity.outcome === "dequeued" &&
+        queue.activeWarrant.phase === "provisional"
+      ) {
         return retainDequeuedWarrant(
           queue,
           identity,

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

@@ -19,7 +19,10 @@ import {
   normalizeNativeCommandContract,
   validateActiveDevDeliveryWarrant,
 } from "./dev-delivery-native-proof.js";
-import { normalizeProviderFailureAuthorityBinding } from "./dev-delivery-warrant-settlement.js";
+import {
+  normalizeProviderFailureAuthorityBinding,
+  normalizeTerminalEvidenceCorrection,
+} from "./dev-delivery-warrant-settlement.js";
 import {
   compareReleaseBlockerPriority,
   normalizeReleaseBlockerPriorityClaim,
@@ -244,8 +247,18 @@ function normalizeCandidate(input, expected) {
         "provider failure authority can exist only on terminal-failure state",
       );
     }
-    if (failureAuthority) {
+    if (failureAuthority)
       candidate.terminal = { ...candidate.terminal, ...failureAuthority };
+    if (candidate.terminal.integrationEvidenceCorrection) {
+      candidate.terminal.integrationEvidenceCorrection =
+        normalizeTerminalEvidenceCorrection(
+          candidate.terminal.integrationEvidenceCorrection,
+          {
+            candidate,
+            repository: expected.repository,
+            protectedBase: expected.protectedBase,
+          },
+        );
     }
   }
   if (Object.hasOwn(input, "affectedPaths")) {

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

@@ -11,7 +11,9 @@ import {
   createCancelQueuedDevDeliveryCandidate,
 } from "./dev-delivery-warrant-cancellation.js";
 import {
+  createDevDeliveryTerminalEvidenceReconciler,
   DEV_DELIVERY_SETTLEMENT_RECEIPT_SCHEMA,
+  DEV_DELIVERY_TERMINAL_EVIDENCE_CORRECTION_SCHEMA,
   createDevDeliveryTerminalSettler,
   normalizeProviderFailureAuthorityBinding,
 } from "./dev-delivery-warrant-settlement.js";
@@ -91,6 +93,7 @@ export {
 };
 export { DEV_DELIVERY_CANCELLATION_RECEIPT_SCHEMA };
 export { DEV_DELIVERY_SETTLEMENT_RECEIPT_SCHEMA };
+export { DEV_DELIVERY_TERMINAL_EVIDENCE_CORRECTION_SCHEMA };
 
 export function selectDevDeliveryWarrant(
   queueInput,
@@ -437,6 +440,10 @@ export function closeDevDeliveryWarrant(
         ...(failureAuthority || {}),
       };
       queue.activeWarrant = null;
+      candidate.terminal.successorWake = createDevDeliverySuccessorWake(
+        queue,
+        currentTime,
+      );
       return { candidate, active };
     },
     currentTime,
@@ -453,10 +460,7 @@ export function closeDevDeliveryWarrant(
     ...(failureAuthority || {}),
     expectedOldStateRoot: transaction.expectedOldStateRoot,
     nextStateRoot: transaction.after.stateRoot,
-    successorWake: createDevDeliverySuccessorWake(
-      transaction.after,
-      currentTime,
-    ),
+    successorWake: transaction.result.candidate.terminal.successorWake,
     nextAction: "Select the next queued candidate, if any.",
   };
   return {
@@ -514,6 +518,11 @@ export const settleDevDeliveryTerminalEvent = createDevDeliveryTerminalSettler({
   cancelQueued: cancelQueuedDevDeliveryCandidate,
   terminalStates: TERMINAL_STATES,
 });
+export const reconcileDevDeliveryTerminalEvidence =
+  createDevDeliveryTerminalEvidenceReconciler({
+    normalizeQueue: normalizeDevDeliveryQueue,
+    transition,
+  });
 export function observeDevDeliveryQueue(
   queueInput,
   { now = new Date().toISOString(), allowLegacyV3Readback = false } = {},
@@ -543,6 +552,14 @@ export function observeDevDeliveryQueue(
         ) || null
       : null,
     states,
+    pendingSuccessorWakes: queue.candidates
+      .filter((candidate) => candidate.terminal?.successorWake)
+      .map((candidate) => ({
+        pullRequestNumber: candidate.pullRequestNumber,
+        sourceHead: candidate.sourceHead,
+        outcome: candidate.status,
+        successorWake: candidate.terminal.successorWake,
+      })),
     queued: queued.map((entry, index) => ({
       position: index + 1,
       candidateId: entry.candidate.candidateId,

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

@@ -110,6 +110,8 @@ const PUBLIC_REPOSITORY_TARGETS = Object.freeze({
   "site-libkungfu-dev": [
     target("main", [check("web-surface / Record web-surface controller receipt")], false),
   ],
+  taolu: ["dev", "alpha", "release"].map((family) => target(`${family}/v1/v1.0`,
+    [check("build / Summarize build contract"), check("stage-capsule / Reconcile exact three-platform evidence")], false)),
 });
 const PUBLIC_REPOSITORIES = Object.freeze(Object.keys(PUBLIC_REPOSITORY_TARGETS).sort());
 const PROTECTED_AUTHORITY_PATHS = Object.freeze([
@@ -497,10 +499,8 @@ export function createBuildchainGithubGovernanceAuthority() {
       privateRepositoryPolicy: "excluded-from-managed-zone",
       unknownRepositoryPolicy: "non-authoritative-until-explicit-admission",
       baseline: {
-        observedOn: "2026-07-30",
-        repositoryCount: 16,
-        publicCount: 16,
-        privateCount: 0,
+        observedOn: "2026-08-28", repositoryCount: 17,
+        publicCount: 17, privateCount: 0,
         authoritativePublicTargetCount: Object.values(PUBLIC_REPOSITORY_TARGETS)
           .reduce((count, targets) => count + targets.length, 0),
       },

package/packages/core/index.js

@@ -646,6 +646,7 @@ export {
 export * from "./release-propagation.js";
 export * from "./v4-floating-consumer-policy.js";
 export * from "./v4-runtime-ref-resume-authority.js";
+export * from "./v4-publication-qualification.js";
 
 export {
   RELEASE_ACTIVATION_CONTRACT,