@kungfu-tech/buildchain 3.0.8 → 3.0.9-alpha.0

package/docs/release-passport.md

@@ -399,18 +399,24 @@ instead of trusting docs or release notes.
 
 ### KFD support projection
 
-Pass `--kfd-support-matrix-json` together with three
-`--kfd-product-gate-json` arguments for KFD-4, KFD-5, and KFD-7. The collector
-verifies the product-owned KFD-1..13 matrix against the installed
-`@kungfu-tech/kfd` standards, binds each gate to the exact release source and
-fresh evidence cut, and emits `kfd-support.json`. The identical projection is
-embedded as `kfdSupport` in `buildchain.release.json`.
-
-Release verification fails closed when the sibling is missing or differs,
-when a gate expires, when matrix and gate status disagree, or when a matrix
-widens KFD-4/5 candidate, KFD-6 unsupported, KFD-8..13 draft, or any non-shipped
-state. A passed projection is release evidence only; product qualification,
-activation, certification, and support ownership remain outside Buildchain.
+Pass the standard full-cut declaration with `--kfd-adopter-manifest-json`
+together with three `--kfd-product-gate-json` arguments for KFD-4, KFD-5, and
+KFD-7. The collector invokes the verifier from the exact installed
+`@kungfu-tech/kfd` package, binds the package artifact, registry and verifier
+roots, the exact Buildchain source, the manifest/report/bundle witness roots,
+and the existing product-gate roots. It emits `kfd-adopter-manifest.json`,
+`kfd-adopter-manifest-gate.json`, and a legacy `kfd-support.json` projection.
+The release passport and `artifact-evidence.json` carry the same rooted
+`kfdAdopter` binding.
+
+The adopter manifest is the sole declaration authority. The old
+`--kfd-support-matrix-json` input is retained only as a compatibility check: if
+supplied with the manifest, it must exactly equal the generated legacy
+projection. Release verification fails closed when any sibling, package root,
+source root, witness root, gate root, passport binding, or artifact-evidence
+binding differs. A passed binding is release evidence only; product
+qualification, activation, certification, and support ownership remain outside
+Buildchain.
 
 ### Floating Buildchain contract lock
 

package/docs/release-train.md

@@ -74,6 +74,14 @@ an invalid transition fails closed.
 changing `trainRoot`, `cutRoot`, candidate identity, generation, or state. The
 same exact observation is idempotent.
 
+Buildchain v3 Candidate Patrol resolves the open managed candidate's persisted
+train before it considers a new qualified development head. It reads back the
+candidate ref and tree, Alpha base, and exact Buildchain runtime. Matching
+coordinates resume the frozen candidate; a newer development head becomes a
+single rooted observation. Candidate, tree, base, runtime, or route drift emits
+a rooted hold and stops settlement. Only a validated train already carrying an
+enumerated `superseded` transition is reported as superseded.
+
 ## Readback and legacy state
 
 `validateReleaseCut()` checks the standalone immutable cut and its canonical

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kungfu-tech/buildchain",
-  "version": "3.0.8",
+  "version": "3.0.9-alpha.0",
   "private": false,
   "description": "Buildchain Release Passport, release governance, CLI toolkit, and site facts.",
   "repository": "https://github.com/kungfu-systems/buildchain",
@@ -33,6 +33,8 @@
     "./issue-reporting": "./packages/core/issue-reporting.js",
     "./kfd": "./packages/core/kfd.js",
     "./kfd-product-gates": "./packages/core/kfd-product-gates.js",
+    "./kfd-adopter-manifest": "./packages/core/kfd-adopter-manifest.js",
+    "./kfd-adopter-release-binding": "./packages/core/artifact-verification-envelope.js",
     "./kfd-agent-hub": "./packages/core/kfd-agent-hub.js",
     "./buildchain-layout": "./packages/core/buildchain-layout.js",
     "./release-line-bootstrap": "./packages/core/release-line-bootstrap.js",
@@ -87,7 +89,6 @@
     "./site/schemas/release-passport-v1.schema.json": "./dist/site/schemas/release-passport-v1.schema.json",
     "./site/schemas/kfd-agent-hub-adoption.schema.json": "./dist/site/schemas/kfd-agent-hub-adoption.schema.json",
     "./site/schemas/kfd-product-gate-input-v1.schema.json": "./dist/site/schemas/kfd-product-gate-input-v1.schema.json",
-    "./site/schemas/kfd-support-projection-v1.schema.json": "./dist/site/schemas/kfd-support-projection-v1.schema.json",
     "./site/buildchain-contract.json": "./dist/site/buildchain-contract.json",
     "./site/product-mechanism.json": "./dist/site/product-mechanism.json",
     "./site/release-provenance.json": "./dist/site/release-provenance.json",
@@ -139,7 +140,7 @@
     "typescript": "^5.9.0"
   },
   "dependencies": {
-    "@kungfu-tech/kfd": "1.0.0-alpha.53",
+    "@kungfu-tech/kfd": "1.0.0-alpha.60",
     "ajv": "8.20.0",
     "smol-toml": "1.7.0"
   }

package/packages/core/artifact-verification-envelope.js

@@ -1,4 +1,11 @@
 import crypto from "node:crypto";
+import kfdPackageJson from "@kungfu-tech/kfd/package.json" with { type: "json" };
+import kfdSelfAdopterManifest from "@kungfu-tech/kfd/adopter-conformance/adopters/kfd/manifest.json" with { type: "json" };
+import {
+  validateKfdAdopterManifestGate,
+  validateKfdLegacySupportMatrixProjection,
+} from "./kfd-adopter-manifest.js";
+import { kfdProductGateDigest } from "./kfd-product-gates.js";
 
 export const ARTIFACT_VERIFICATION_ENVELOPE_CONTRACT =
   "kungfu-buildchain-artifact-verification-envelope";
@@ -6,6 +13,8 @@ export const ARTIFACT_VERIFICATION_ENVELOPE_CHECK_CONTRACT =
   "kungfu-buildchain-artifact-verification-envelope-check";
 export const KFX_ADMISSION_INPUTS_CONTRACT =
   "kungfu-buildchain-kfx-admission-inputs";
+export const KFD_ADOPTER_RELEASE_BINDING_CONTRACT =
+  "kungfu-buildchain-kfd-adopter-release-binding";
 
 const ARTIFACT_VERIFICATION_CONTRACT =
   "kungfu-buildchain-artifact-verification";
@@ -384,3 +393,108 @@ export function projectArtifactVerificationEnvelopeToKfx({
     kfdAssessment: jsonClone(envelope.kfdAssessment),
   };
 }
+
+export function installedKfdPackageArtifactRoot() {
+  const cut = kfdSelfAdopterManifest?.kfdCut?.package;
+  if (cut?.name !== kfdPackageJson.name || cut?.version !== kfdPackageJson.version
+    || !SHA256_PATTERN.test(String(cut?.artifactRoot || ""))) {
+    throw new Error("installed KFD package does not expose a matching rooted self-adopter package cut");
+  }
+  return cut.artifactRoot;
+}
+
+function kfdBindingBody({ manifest, manifestGate, legacyProjection, paths }) {
+  return {
+    schemaVersion: 1,
+    contract: KFD_ADOPTER_RELEASE_BINDING_CONTRACT,
+    status: "passed",
+    qualifying: false,
+    selfCertified: false,
+    authority: {
+      manifestPath: paths.manifest,
+      manifestContract: manifest.contract,
+      manifestRoot: manifestGate.authority.manifestRoot,
+      gatePath: paths.gate,
+      gateRoot: manifestGate.gateRoot,
+    },
+    source: jsonClone(manifestGate.source),
+    standardPackage: jsonClone(manifestGate.standardPackage),
+    witness: {
+      decisionRoot: manifestGate.decisionWitness.root,
+      verificationReportRoot: manifestGate.manifestVerificationReportRoot,
+      bundleRoot: manifestGate.manifestBundleRoot,
+    },
+    legacyProjection: {
+      path: paths.legacy,
+      contract: legacyProjection.contract,
+      root: kfdProductGateDigest(legacyProjection),
+      authorityRoot: legacyProjection.authority.root,
+      gateRoot: legacyProjection.authority.gateRoot,
+    },
+    nonClaims: [
+      "This binding proves exact release-envelope consumption, not KFD certification or release authorization.",
+      "The legacy support matrix remains a projection of the standard adopter manifest authority.",
+    ],
+  };
+}
+
+export function createKfdAdopterReleaseBinding({
+  manifest,
+  manifestGate,
+  legacyProjection,
+  manifestPath = "kfd-adopter-manifest.json",
+  gatePath = "kfd-adopter-manifest-gate.json",
+  legacyProjectionPath = "kfd-support.json",
+  expectedSourceSha = "",
+} = {}) {
+  const gate = validateKfdAdopterManifestGate(manifestGate, {
+    expectedSourceSha,
+    checkedAt: manifestGate?.checkedAt,
+  });
+  const legacy = validateKfdLegacySupportMatrixProjection(legacyProjection, { manifest, manifestGate });
+  if (!gate.valid || !legacy.valid) {
+    throw new Error(`KFD adopter release binding inputs are invalid: ${JSON.stringify([...gate.issues, ...legacy.issues])}`);
+  }
+  const body = kfdBindingBody({
+    manifest,
+    manifestGate,
+    legacyProjection,
+    paths: { manifest: manifestPath, gate: gatePath, legacy: legacyProjectionPath },
+  });
+  return { ...body, bindingRoot: kfdProductGateDigest(body) };
+}
+
+export function validateKfdAdopterReleaseBinding(binding, {
+  manifest,
+  manifestGate,
+  legacyProjection,
+  expectedSourceSha = "",
+} = {}) {
+  const issues = [];
+  if (!binding || binding.schemaVersion !== 1 || binding.contract !== KFD_ADOPTER_RELEASE_BINDING_CONTRACT) {
+    return { valid: false, issues: [{ code: "adopter-release-binding-contract", path: "", message: `binding must use ${KFD_ADOPTER_RELEASE_BINDING_CONTRACT} v1` }] };
+  }
+  const copy = jsonClone(binding);
+  const bindingRoot = copy.bindingRoot;
+  delete copy.bindingRoot;
+  if (bindingRoot !== kfdProductGateDigest(copy)) {
+    issues.push({ code: "adopter-release-binding-root", path: "bindingRoot", message: "release binding root does not match its content" });
+  }
+  try {
+    const expected = createKfdAdopterReleaseBinding({
+      manifest,
+      manifestGate,
+      legacyProjection,
+      manifestPath: binding.authority?.manifestPath,
+      gatePath: binding.authority?.gatePath,
+      legacyProjectionPath: binding.legacyProjection?.path,
+      expectedSourceSha,
+    });
+    if (stableJson(binding) !== stableJson(expected)) {
+      issues.push({ code: "adopter-release-binding-drift", path: "", message: "release binding differs from the exact manifest, gate, or legacy projection closure" });
+    }
+  } catch (error) {
+    issues.push({ code: "adopter-release-binding-authority", path: "", message: error.message });
+  }
+  return { valid: issues.length === 0, issues };
+}

package/packages/core/dev-alpha-active-release-train.js

@@ -0,0 +1,460 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import crypto from "node:crypto";
+import {
+  createReleaseTrain,
+  observeReleaseTrain,
+  validateReleaseTrain,
+} from "./release-train.js";
+
+export const RELEASE_TRAIN_HOLD_SCHEMA =
+  "kungfu-buildchain-release-train-hold/v1";
+
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, canonical(item)]),
+    );
+  }
+  return value;
+}
+
+function evidenceRoot(value) {
+  return `sha256:${crypto
+    .createHash("sha256")
+    .update(JSON.stringify(canonical(value)))
+    .digest("hex")}`;
+}
+
+function sameHold(left, right) {
+  return (
+    left?.schema === RELEASE_TRAIN_HOLD_SCHEMA &&
+    right?.schema === RELEASE_TRAIN_HOLD_SCHEMA &&
+    left.trainRoot === right.trainRoot &&
+    left.code === right.code &&
+    left.observedDevSha === right.observedDevSha &&
+    left.observedCandidateSha === right.observedCandidateSha &&
+    left.observedCandidateTreeSha === right.observedCandidateTreeSha &&
+    left.observedAlphaBaseSha === right.observedAlphaBaseSha &&
+    left.observedRuntimeSha === right.observedRuntimeSha
+  );
+}
+
+function releaseTrainHold({
+  train,
+  code,
+  reason,
+  observedDevSha,
+  observedCandidateSha,
+  observedCandidateTreeSha,
+  observedAlphaBaseSha,
+  observedRuntimeSha,
+  recordedAt,
+  priorHold,
+}) {
+  const body = {
+    schema: RELEASE_TRAIN_HOLD_SCHEMA,
+    trainRoot: train.trainRoot,
+    cutRoot: train.releaseCut.cutRoot,
+    generation: train.releaseCut.generation,
+    candidateSha: train.releaseCut.candidateSha,
+    candidateTreeSha: train.releaseCut.candidateTreeSha,
+    code,
+    reason,
+    observedDevSha,
+    observedCandidateSha,
+    observedCandidateTreeSha,
+    observedAlphaBaseSha,
+    observedRuntimeSha,
+    recordedAt,
+  };
+  if (sameHold(priorHold, body)) return priorHold;
+  return { ...body, holdRoot: evidenceRoot(body) };
+}
+
+export function observeDevOnce(train, observedDevSha, observedAt) {
+  if (
+    train.observations.some(
+      (observation) => observation.observedDevSha === observedDevSha,
+    )
+  ) {
+    return train;
+  }
+  return observeReleaseTrain(train, { observedDevSha, observedAt });
+}
+
+export async function resolveManagedCandidate({
+  client,
+  targetBranch,
+  repository,
+  sourceBranch,
+  parseCandidate,
+}) {
+  const openPullRequests = await client.listOpenPullRequests(targetBranch);
+  const managed = openPullRequests
+    .map((pullRequest) => parseCandidate(pullRequest, targetBranch))
+    .filter(Boolean);
+  for (const candidate of managed) {
+    if (
+      candidate.state &&
+      (candidate.state.repository !== repository ||
+        candidate.state.sourceBranch !== sourceBranch)
+    ) {
+      throw new Error(
+        `candidate PR #${candidate.number} state does not bind ${repository} ${sourceBranch}`,
+      );
+    }
+  }
+  if (managed.length > 1) {
+    throw new Error(
+      `multiple open Buildchain candidate PRs target ${targetBranch}: ${managed
+        .map((candidate) => `#${candidate.number}`)
+        .join(", ")}`,
+    );
+  }
+  return managed[0] || null;
+}
+
+export async function cutInitialReleaseTrain({
+  options,
+  client,
+  decision,
+  candidate,
+  sourceSha,
+  targetSha,
+  observedSourceHeadSha,
+}) {
+  if (!candidate) return null;
+  if (!options.buildchainRuntimeSha) {
+    throw new Error(
+      "buildchainRuntimeSha is required to cut an active Release Train",
+    );
+  }
+  if (!client.resolveCommitTreeSha) {
+    throw new Error(
+      "active Release Train creation requires candidate tree readback",
+    );
+  }
+  const candidateTreeSha = await client.resolveCommitTreeSha(sourceSha);
+  let train = createReleaseTrain({
+    repository: options.repository,
+    sourceBranch: options.sourceBranch,
+    targetBranch: options.targetBranch,
+    originDevSha: sourceSha,
+    candidateSha: sourceSha,
+    candidateTreeSha,
+    alphaBaseSha: targetSha,
+    buildchainRuntimeSha: options.buildchainRuntimeSha,
+    generation: 1,
+    authorityRoots: [decision.decisionRoot, candidate.qualificationRoot].sort(),
+    createdAt: options.cutCreatedAt || options.now,
+  });
+  train = observeDevOnce(train, observedSourceHeadSha, options.now);
+  if (
+    options.expectedCutRoot &&
+    train.releaseCut.cutRoot !== options.expectedCutRoot
+  ) {
+    throw new Error(
+      `Release Cut changed between observation and settlement: expected ${options.expectedCutRoot}, observed ${train.releaseCut.cutRoot}`,
+    );
+  }
+  return train;
+}
+
+export function reconcileActiveReleaseTrain({
+  releaseTrain,
+  repository,
+  sourceBranch,
+  targetBranch,
+  activeCandidateSha,
+  sourceLockSha,
+  candidateTreeSha,
+  alphaBaseSha,
+  buildchainRuntimeSha,
+  observedDevSha,
+  observedAt,
+  priorHold = null,
+}) {
+  const train = observeDevOnce(
+    validateReleaseTrain(releaseTrain),
+    observedDevSha,
+    observedAt,
+  );
+  if (train.state.status === "superseded") {
+    return { status: "superseded", train, hold: null };
+  }
+  const cut = train.releaseCut;
+  const checks = [
+    [
+      cut.repository !== repository ||
+        cut.sourceBranch !== sourceBranch ||
+        cut.targetBranch !== targetBranch,
+      "invalid-authority",
+      "the active Release Cut route no longer matches the controller route",
+    ],
+    [
+      activeCandidateSha !== cut.candidateSha ||
+        sourceLockSha !== cut.candidateSha,
+      "candidate-ref-drift",
+      "the managed candidate PR or source-lock ref drifted from the frozen candidate",
+    ],
+    [
+      candidateTreeSha !== cut.candidateTreeSha,
+      "candidate-tree-drift",
+      "the frozen candidate tree readback does not match the Release Cut",
+    ],
+    [
+      alphaBaseSha !== cut.alphaBaseSha,
+      "alpha-base-drift",
+      "the Alpha base moved after the Release Cut and requires explicit supersession or repair",
+    ],
+    [
+      buildchainRuntimeSha !== cut.buildchainRuntimeSha,
+      "runtime-drift",
+      "the Buildchain runtime moved after the Release Cut and requires explicit supersession or repair",
+    ],
+  ];
+  const failure = checks.find(([failed]) => failed);
+  if (failure) {
+    const [, code, reason] = failure;
+    return {
+      status: "held",
+      train,
+      hold: releaseTrainHold({
+        train,
+        code,
+        reason,
+        observedDevSha,
+        observedCandidateSha: sourceLockSha,
+        observedCandidateTreeSha: candidateTreeSha,
+        observedAlphaBaseSha: alphaBaseSha,
+        observedRuntimeSha: buildchainRuntimeSha,
+        recordedAt: observedAt,
+        priorHold,
+      }),
+    };
+  }
+  return {
+    status: "active",
+    train,
+    hold: null,
+    drift: {
+      observedDevSha,
+      originDevSha: cut.originDevSha,
+      moved: observedDevSha !== cut.originDevSha,
+      observationRoot:
+        train.observations.find(
+          (observation) => observation.observedDevSha === observedDevSha,
+        )?.observationRoot || null,
+    },
+  };
+}
+
+function activeTrainDecision({
+  options,
+  candidate,
+  reconciliation,
+  observedSourceHeadSha,
+  targetSha,
+}) {
+  const cut = reconciliation.train.releaseCut;
+  const eligible = reconciliation.status === "active";
+  const body = {
+    schema: "kungfu-buildchain-channel-candidate-decision/v1",
+    eligible,
+    reason: eligible
+      ? "active-release-train"
+      : reconciliation.status === "superseded"
+        ? "active-release-train-superseded"
+        : "active-release-train-held",
+    repository: options.repository,
+    source: { branch: options.sourceBranch, sha: cut.candidateSha },
+    target: { branch: options.targetBranch, sha: targetSha },
+    comparison: { status: "frozen-release-cut", aheadBy: 0 },
+    selection: {
+      mode: "active-release-train",
+      observedSourceHeadSha,
+      skippedNewerCommitCount: 0,
+      trainRoot: reconciliation.train.trainRoot,
+      cutRoot: cut.cutRoot,
+      generation: cut.generation,
+      candidateTreeSha: cut.candidateTreeSha,
+    },
+    workflowEvidence: [],
+    requiredWorkflowPaths: [],
+    sourceLockRef: candidate.sourceLockRef,
+    ...(reconciliation.hold
+      ? {
+          blockReason: reconciliation.hold.reason,
+          holdRoot: reconciliation.hold.holdRoot,
+        }
+      : {}),
+    decidedAt: options.now,
+  };
+  return { ...body, decisionRoot: evidenceRoot(body) };
+}
+
+function candidateIdentity(candidate) {
+  return {
+    sourceSha: candidate.sourceSha,
+    sourceLockRef: candidate.sourceLockRef,
+    decisionRoot: candidate.decisionRoot || null,
+    pullRequestNumber: candidate.number,
+    pullRequestUrl: candidate.url,
+  };
+}
+
+function semanticState(value) {
+  if (!value) return null;
+  const normalized = { ...value };
+  delete normalized.observedAt;
+  delete normalized.observationDecisionRoot;
+  delete normalized.stateRoot;
+  delete normalized.priorStateRoot;
+  return normalized;
+}
+
+export async function runActiveReleaseTrain({
+  options,
+  client,
+  activeCandidate,
+  adapters,
+}) {
+  const [observedSourceHeadSha, targetSha, sourceLockSha] = await Promise.all([
+    client.resolveBranch(options.sourceBranch),
+    client.resolveBranch(options.targetBranch),
+    client.resolveBranch(activeCandidate.sourceLockRef),
+  ]);
+  if (!client.resolveCommitTreeSha) {
+    throw new Error(
+      "active Release Train validation requires candidate tree readback",
+    );
+  }
+  const candidateTreeSha = await client.resolveCommitTreeSha(
+    activeCandidate.sourceSha,
+  );
+  const reconciliation = reconcileActiveReleaseTrain({
+    releaseTrain: activeCandidate.releaseTrain,
+    repository: options.repository,
+    sourceBranch: options.sourceBranch,
+    targetBranch: options.targetBranch,
+    activeCandidateSha: activeCandidate.sourceSha,
+    sourceLockSha,
+    candidateTreeSha,
+    alphaBaseSha: targetSha,
+    buildchainRuntimeSha: options.buildchainRuntimeSha,
+    observedDevSha: observedSourceHeadSha,
+    observedAt: options.now,
+    priorHold: activeCandidate.hold,
+  });
+  if (
+    options.expectedCutRoot &&
+    reconciliation.train.releaseCut.cutRoot !== options.expectedCutRoot
+  ) {
+    throw new Error(
+      `active Release Cut changed between observation and settlement: expected ${options.expectedCutRoot}, observed ${reconciliation.train.releaseCut.cutRoot}`,
+    );
+  }
+  const decision = activeTrainDecision({
+    options,
+    candidate: activeCandidate,
+    reconciliation,
+    observedSourceHeadSha,
+    targetSha,
+  });
+  if (
+    options.expectedSelectedSha &&
+    decision.source.sha !== options.expectedSelectedSha
+  ) {
+    throw new Error(
+      `selected source changed between observation and settlement: expected ${options.expectedSelectedSha}, observed ${decision.source.sha}`,
+    );
+  }
+  const priorStateRoot = adapters.persistedStateRoot(activeCandidate);
+  if (
+    options.expectedPriorStateRoot &&
+    options.expectedPriorStateRoot !== priorStateRoot
+  ) {
+    throw new Error(
+      `candidate controller compare-and-swap failed: expected prior state root ${options.expectedPriorStateRoot}, observed ${priorStateRoot}`,
+    );
+  }
+  const desiredState = adapters.candidateStateBody({
+    options,
+    targetSha,
+    decision,
+    activeCandidate: candidateIdentity(activeCandidate),
+    nextCandidate: null,
+    supersededCandidate: null,
+    priorStateRoot,
+    generation: reconciliation.train.releaseCut.generation,
+    tombstones: activeCandidate.state?.tombstones || [],
+    releaseTrain: reconciliation.train,
+    hold: reconciliation.hold,
+  });
+  const transitionNeeded =
+    !activeCandidate.state ||
+    JSON.stringify(canonical(semanticState(activeCandidate.state))) !==
+      JSON.stringify(canonical(semanticState(desiredState)));
+  const state = transitionNeeded ? desiredState : activeCandidate.state;
+  let settlementAction = "none";
+  if (transitionNeeded && options.settlementAuthorized && !options.dryRun) {
+    const nextBody = adapters.replaceCandidateStateMarker(
+      activeCandidate.body,
+      state,
+    );
+    await client.updatePullRequestBody(
+      activeCandidate.number,
+      nextBody,
+      priorStateRoot,
+    );
+    settlementAction =
+      reconciliation.status === "held"
+        ? "hold-active-release-train"
+        : reconciliation.status === "superseded"
+          ? "record-superseded-release-train"
+          : "observe-active-release-train";
+  }
+  const pullRequest = adapters.activePullRequest(activeCandidate);
+  const autoMerge = await adapters.armCandidateAutoMerge(
+    options,
+    reconciliation.status,
+    pullRequest,
+    client,
+  );
+  return {
+    schema: "kungfu-buildchain-dev-alpha-candidate-patrol/v1",
+    dryRun: options.dryRun,
+    createPullRequest: options.createPullRequest,
+    settlementAuthorized: options.settlementAuthorized,
+    autoMerge,
+    decision,
+    releaseTrain: reconciliation.train,
+    drift: reconciliation.drift || null,
+    hold: reconciliation.hold,
+    controller: {
+      schema: adapters.stateSchema,
+      state: reconciliation.status,
+      activeCandidate,
+      nextCandidate: null,
+      supersededCandidate: null,
+      settlementAction,
+      stateRoot: state.stateRoot,
+      priorStateRoot,
+      generation: reconciliation.train.releaseCut.generation,
+      trainRoot: reconciliation.train.trainRoot,
+      cutRoot: reconciliation.train.releaseCut.cutRoot,
+      candidateTreeSha: reconciliation.train.releaseCut.candidateTreeSha,
+      buildchainRuntimeSha:
+        reconciliation.train.releaseCut.buildchainRuntimeSha,
+      cutCreatedAt: reconciliation.train.releaseCut.createdAt,
+      observedAt: options.now,
+      holdRoot: reconciliation.hold?.holdRoot || null,
+      tombstones: state.tombstones || [],
+    },
+    pullRequest,
+  };
+}