@kungfu-tech/buildchain 4.1.3-alpha.1 → 4.1.3-alpha.10

package/packages/core/workflow/pipeline/selection.js

@@ -0,0 +1,111 @@
+import { readBusinessAttempt } from "../attempt/reader.js";
+import { openPipelineSession, resumePipelineSession } from "./session.js";
+import { sourceGeneration } from "../attempt/identity.js";
+
+async function successorSelection(
+  session,
+  admission,
+  event,
+  payload,
+  inputs,
+  host,
+) {
+  const failedBuild =
+    session.observed.status === "failure" &&
+    session.observed.phases.build?.payload.state === "failure";
+  if (
+    (!failedBuild &&
+      !["superseded", "cancelled"].includes(session.observed.status)) ||
+    event.terminalOnly ||
+    admission.live.state !== "open" ||
+    admission.live.targetBranch !== session.intent.source.targetBranch
+  )
+    return { session, admission };
+  const next = await host.source.observe(
+    session.intent.source.pullRequest,
+    inputs,
+  );
+  if (!next.eligible) return { session, admission };
+  const changed =
+    sourceGeneration(session.intent, next.live.source, next.live.baseCommit)
+      .id !== session.observed.generation;
+  if (
+    !changed &&
+    (failedBuild ||
+      !["reopened", "enqueued", "ready_for_review", "labeled"].includes(
+        payload.action,
+      ))
+  )
+    return { session, admission };
+  await host.notifyTerminal?.(session);
+  return {
+    session: await openPipelineSession(
+      { admission: next, ...host, successor: true },
+      host,
+    ),
+    admission: next,
+  };
+}
+
+// Event branch names are lookup hints only. The immutable intent and live PR
+// readback decide whether an old route still needs cleanup before a new route.
+export async function selectPipelineSession(event, payload, inputs, host) {
+  if (event.kind === "attempt") {
+    const session = await resumePipelineSession(
+      { ...host, attempt: event.attempt },
+      host,
+    );
+    const admission = await host.source.observeIntent(
+      session.intent,
+      session.observed.history.at(-1).generation,
+      inputs,
+    );
+    return successorSelection(session, admission, event, payload, inputs, host);
+  }
+  if (event.kind !== "pull-request")
+    throw new Error("Not a PR pipeline selection");
+  const pr = await host.request(
+    `/repos/${host.repository}/pulls/${event.pullRequest}`,
+  );
+  const branches = [
+    ...new Set(
+      [payload.changes?.base?.ref?.from, pr.base?.ref].filter(Boolean),
+    ),
+  ];
+  for (const branch of branches) {
+    if (!/^(?:dev|alpha|release|publish-gate)\/[A-Za-z0-9/._-]+$/u.test(branch))
+      continue;
+    const retained = await host.provider.lookup(
+      host.repository,
+      event.pullRequest,
+      branch,
+    );
+    if (!retained) continue;
+    const observed = readBusinessAttempt(retained.snapshot);
+    if (!observed.attempt) continue;
+    if (
+      branch !== pr.base.ref &&
+      ["cancelled", "failure", "superseded", "complete"].includes(
+        observed.status,
+      )
+    )
+      continue;
+    const session = await resumePipelineSession(
+      { ...host, attempt: observed.attempt },
+      host,
+    );
+    const admission = await host.source.observeIntent(
+      session.intent,
+      observed.history.at(-1).generation,
+      inputs,
+    );
+    return successorSelection(session, admission, event, payload, inputs, host);
+  }
+  if (event.terminalOnly || pr.state !== "open") return null;
+  const admission = await host.source.observe(event.pullRequest, inputs);
+  if (!admission.eligible) return null;
+  return {
+    session: await openPipelineSession({ admission, ...host }, host),
+    admission,
+  };
+}

package/packages/core/workflow/pipeline/session.js

@@ -0,0 +1,72 @@
+import { pipelineIntent } from "../attempt/identity.js";
+import { atomicAttemptJournal } from "../attempt/journal.js";
+import { pipelineProgress } from "./progress.js";
+
+export function pipelinePhases(operation) {
+  if (operation === "develop")
+    return ["admission", "build", "review", "warrant", "merge"];
+  if (["alpha", "stable", "major"].includes(operation))
+    return [
+      "admission",
+      "build",
+      "review",
+      "merge",
+      "publish",
+      "distribution",
+      "next-development",
+    ];
+  throw new Error("Unsupported pipeline channel operation");
+}
+
+export async function openPipelineSession(
+  { admission, runtime, writer, successor = false },
+  { provider, index },
+) {
+  if (!admission.eligible || !admission.route || !admission.live.source)
+    throw new Error(
+      "A new pipeline attempt requires an admitted source and channel",
+    );
+  const { live } = admission;
+  const retained = await provider.lookup(
+    live.source.repository,
+    live.pullRequest,
+    admission.route.to,
+  );
+  const intent =
+    retained?.snapshot.intent ||
+    pipelineIntent({
+      repository: live.source.repository,
+      repositoryId: admission.repositoryId,
+      pullRequest: live.pullRequest,
+      targetBranch: admission.route.to,
+      phases: pipelinePhases(admission.route.operation),
+      runtime,
+    });
+  const journal = atomicAttemptJournal(provider, intent);
+  const progress = pipelineProgress(journal, { intent, writer, runtime });
+  const observed = await progress.open(live.source, live.baseCommit, {
+    successor,
+  });
+  await index.retain(intent, observed.attempt);
+  return { intent, journal, progress, observed };
+}
+
+export async function resumePipelineSession(
+  { attempt, runtime, writer },
+  { provider, index },
+) {
+  const retained = await index.resolve(attempt);
+  const intent = retained.snapshot.intent;
+  const journal = atomicAttemptJournal(provider, intent);
+  const observed = await journal.read();
+  if (observed.attempt !== attempt)
+    throw new Error(
+      "Selected attempt is historical; it cannot regain current write authority",
+    );
+  return {
+    intent,
+    journal,
+    observed,
+    progress: pipelineProgress(journal, { intent, writer, runtime }),
+  };
+}

package/packages/core/workflow/pipeline/settlement.js

@@ -0,0 +1,137 @@
+import {
+  createIntegrationDeliveryProof,
+  verifyIntegrationDeliveryProof,
+} from "../../dev-delivery/dev-delivery-warrant.js";
+import { readBusinessAttempt } from "../attempt/reader.js";
+import { pipelineCandidate } from "./reconcile.js";
+
+async function qualifyWarrant(session, current, queue, materials) {
+  if (current.phases.warrant?.payload.state === "success") return;
+  if (queue.activeWarrant?.phase !== "qualified")
+    throw new Error("Merged pipeline has no qualified active Warrant");
+  const reference = await materials.retain(
+    `warrant/qualified-${queue.stateRoot.slice(7)}`,
+    queue,
+    "provider-readback",
+  );
+  await session.progress.progress({
+    attempt: current.identity.id,
+    phase: "warrant",
+    state: "success",
+    eventKey: `qualified:${queue.stateRoot}`,
+    materials: [reference],
+  });
+}
+
+async function integrationProof(session, fresh, host, materials) {
+  const { queue, current } = fresh;
+  const candidate = pipelineCandidate(queue, current);
+  if (!candidate)
+    throw new Error("Merged pipeline candidate authority is missing");
+  if (candidate.status === "merged") {
+    const reference =
+      current.materials[
+        `merge/proof-${candidate.terminal.evidenceRoot.slice(7)}`
+      ];
+    if (!reference)
+      throw new Error(
+        "Merged Warrant has no retained pre-effect integration proof",
+      );
+    const proof = await materials.read(reference);
+    if (
+      !verifyIntegrationDeliveryProof(proof, {
+        sourceProofRoot: candidate.sourceProofRoot,
+        warrantCandidateId: candidate.candidateId,
+      }).ok
+    )
+      throw new Error("Retained integration proof is invalid");
+    return { candidate, proof, reference };
+  }
+  if (candidate.candidateId !== queue.activeWarrant?.candidateId)
+    throw new Error("Merged candidate is not the active Warrant");
+  await qualifyWarrant(session, current, queue, materials);
+  const readback = await host.integration.observe(current);
+  const proof = createIntegrationDeliveryProof({
+    repository: host.repository,
+    protectedBase: session.intent.source.targetBranch,
+    sourceProofRoot: candidate.sourceProofRoot,
+    warrant: queue.activeWarrant,
+    currentBase: readback.mergeCommit,
+    replayTree: readback.mergeTree,
+    mergeGroupHead: readback.mergeCommit,
+    mergeGroupTree: readback.mergeTree,
+    requiredContextRoots: [readback.build.root, readback.root],
+    verifiedAt: new Date().toISOString(),
+  });
+  const reference = await materials.retain(
+    `merge/proof-${proof.proofRoot.slice(7)}`,
+    proof,
+  );
+  const provider = await materials.retain(
+    `merge/provider-${readback.root.slice(7)}`,
+    readback,
+    "provider-readback",
+  );
+  await session.progress.progress({
+    attempt: current.identity.id,
+    phase: "merge",
+    state: "waiting",
+    eventKey: `merge-request:${proof.proofRoot}`,
+    materials: [reference, provider],
+  });
+  return { candidate, proof, reference };
+}
+
+export async function settlePipeline(session, fresh, delivery, host) {
+  const materials = host.materialStore(session);
+  const { candidate, proof, reference } = await integrationProof(
+    session,
+    fresh,
+    host,
+    materials,
+  );
+  const warrant = fresh.queue.activeWarrant;
+  const result = await delivery.service.settle({
+    expectedOldStateRoot: fresh.queue.stateRoot,
+    pullRequestNumber: candidate.pullRequestNumber,
+    expectedSourceHead: candidate.sourceHead,
+    outcome: "merged",
+    reason: "exact-protected-pipeline-integration",
+    evidenceRoot: proof.proofRoot,
+    execute: true,
+    ...(warrant?.candidateId === candidate.candidateId
+      ? {
+          fencingToken: warrant.fencingToken,
+          leaseGeneration: warrant.generation,
+        }
+      : {}),
+  });
+  if (result.observation.activeWarrant?.candidateId === candidate.candidateId)
+    throw new Error("Merged settlement retained its active Warrant");
+  const receipt = await materials.retain(
+    `merge/settlement-${result.receiptRoot.slice(7)}`,
+    result,
+  );
+  await session.progress.progress({
+    attempt: fresh.attempt,
+    phase: "merge",
+    state: "success",
+    eventKey: `merged:${result.receiptRoot}`,
+    materials: [reference, receipt],
+  });
+  await host.notifyTerminal?.(session);
+  const successor = result.receipt.successorWake;
+  if (successor) {
+    const next = await host.provider.lookup(
+      host.repository,
+      successor.pullRequestNumber,
+      session.intent.source.targetBranch,
+    );
+    if (next) await host.wake(readBusinessAttempt(next.snapshot).attempt);
+  }
+  return {
+    operation: "wait",
+    reason: "protected-delivery-settled",
+    attempt: fresh.attempt,
+  };
+}

package/packages/core/workflow/pipeline/wake.js

@@ -0,0 +1,38 @@
+import { githubJsonClient } from "../../providers/github/json-client.js";
+import { githubAttemptJournal } from "../../providers/github/attempt-journal.js";
+import { readBusinessAttempt } from "../attempt/reader.js";
+import { pipelineCandidateRoot } from "./reconcile.js";
+
+export async function wakePipelineCandidate(candidate, connection, ports = {}) {
+  const repository = connection.repository;
+  const request =
+    ports.request ||
+    githubJsonClient({
+      token: connection.token,
+      userAgent: "buildchain-pipeline-wake",
+    });
+  const provider = ports.provider || githubAttemptJournal(request);
+  const branch = candidate.protectedBase || connection.branch;
+  const loaded = await provider.lookup(
+    repository,
+    candidate.pullRequestNumber,
+    branch,
+  );
+  if (!loaded)
+    throw new Error("Warrant handoff has no admitted business intent");
+  const observed = readBusinessAttempt(loaded.snapshot);
+  const current = { ...observed.history.at(-1), intent: observed.intent };
+  if (
+    candidate.sourceHead !== current.generation.source.commit ||
+    candidate.sourceRoot !== pipelineCandidateRoot(current)
+  )
+    throw new Error("Warrant handoff changed its admitted business attempt");
+  await request(`/repos/${repository}/dispatches`, {
+    method: "POST",
+    body: {
+      event_type: "buildchain-attempt-wake",
+      client_payload: { attempt: observed.attempt },
+    },
+  });
+  return observed.attempt;
+}

package/packages/core/workflow/pipeline/web-status.js

@@ -0,0 +1,108 @@
+const labels = {
+  admission: "Source admission",
+  build: "Product verification",
+  review: "Protected review",
+  warrant: "Delivery qualification",
+  merge: "Protected integration",
+  publish: "Product publication",
+  distribution: "Distribution",
+  "next-development": "Next development version",
+};
+const safe = (value) =>
+  String(value || "")
+    .replace(/[\r\n|]/gu, " ")
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replace(/[\\`*_[\]()]/gu, (character) => `\\${character}`)
+    .slice(0, 1000);
+
+export function pipelineWebStatus(observed, discussionUrl = "") {
+  const { intent, attempt } = observed;
+  const repositoryUrl = `https://github.com/${intent.repository}`;
+  const current = observed.history.at(-1);
+  if (!current) throw new Error("Pipeline status requires an admitted attempt");
+  const table = [
+    "| Step | State |",
+    "| --- | --- |",
+    ...intent.expectedNodes.map(
+      (phase) =>
+        `| ${labels[phase]} | ${safe(observed.phases[phase]?.payload.state || "pending")} |`,
+    ),
+  ].join("\n");
+  const lines = [
+    `## Buildchain · PR #${intent.source.pullRequest}`,
+    `Status: **${safe(observed.status)}**. ${safe(observed.reason)}`,
+    `Attempt: \`${attempt}\``,
+    `[Pull request](${repositoryUrl}/pull/${intent.source.pullRequest}) · ` +
+      `[Source ${current.generation.source.commit.slice(0, 7)}](${repositoryUrl}/commit/${current.generation.source.commit})`,
+    table,
+  ];
+  const publisher = [...observed.history]
+    .reverse()
+    .find(
+      (item) =>
+        item.generation.id === current.generation.id &&
+        item.phases.publish?.payload.state === "success",
+    );
+  const published = Boolean(publisher);
+  if (published && observed.missing.length)
+    lines.push(
+      `Publication succeeded and its immutable results remain preserved. The whole attempt is incomplete: ${observed.missing.map((phase) => labels[phase]).join(", ")}.`,
+    );
+  if (publisher && publisher.identity.id !== current.identity.id)
+    lines.push(
+      `Publication succeeded in predecessor \`${publisher.identity.id}\`. Current qualification and remaining steps are shown separately above.`,
+    );
+  if (current.identity.predecessor)
+    lines.push(
+      `Recovered from \`${current.identity.predecessor}\`; its original evidence remains in history.`,
+    );
+  if (observed.status !== "complete")
+    lines.push(
+      `[Recover this attempt](${repositoryUrl}/actions/workflows/buildchain-recover.yml): choose Run workflow and enter the exact attempt above. Select a repaired runtime only when needed.`,
+    );
+  lines.push(
+    "Execution links provide the provider's ordinary cancellation control. Cancellation stops remaining work; it does not undo completed publication.",
+  );
+  const runs = [
+    ...new Map(
+      current.runs.map((run) => [`${run.runId}:${run.runAttempt}`, run]),
+    ).values(),
+  ];
+  for (const run of runs.slice(-10))
+    lines.push(
+      `[Execution ${run.runId}, attempt ${run.runAttempt}](${repositoryUrl}/actions/runs/${run.runId}/attempts/${run.runAttempt})`,
+    );
+  if (discussionUrl) {
+    const url = new URL(discussionUrl);
+    if (
+      url.origin !== "https://github.com" ||
+      !url.pathname.startsWith(`/${intent.repository}/discussions/`) ||
+      !/\/discussions\/[1-9][0-9]*$/u.test(url.pathname) ||
+      url.search ||
+      url.hash ||
+      url.username ||
+      url.password
+    )
+      throw new Error(
+        "Pipeline evidence link belongs to another provider or repository",
+      );
+    lines.push(`[Retained evidence](${discussionUrl})`);
+  }
+  return `${lines.join("\n\n")}\n`;
+}
+
+export async function projectPipelineStatus(session, { project, core }) {
+  let result;
+  try {
+    result = await project(session);
+  } catch {
+    core.warning(
+      "Discussion projection unavailable; canonical attempt evidence remains retained.",
+    );
+  }
+  const observed = await session.journal.read();
+  await core.summary.addRaw(pipelineWebStatus(observed, result?.url)).write();
+  return result || { url: "", journalHead: observed.head };
+}

package/packages/core/workflow/workflow-taxonomy.mjs

@@ -20,7 +20,8 @@ const PROTECTED = [
   "scripts/generate-workflow-taxonomy.mjs",
   "scripts/check-workflows.sh",
   "tests/workflow-taxonomy.test.mjs",
-  ".github/workflows/self-build-verify.yml",
+  ".github/workflows/buildchain.yml",
+  ".github/workflows/buildchain-recover.yml",
   "package.json",
   ".buildchain/buildchain.toml",
 ];
@@ -63,12 +64,13 @@ function validateEntries(policy, errors) {
     if (
       entry.path &&
       !(
-        (entry.id === ".build" || entry.id === "build") &&
-        entry.path === `.github/workflows/${entry.id}.yml`
+        [".build", "build", "buildchain", "buildchain-recover"].includes(
+          entry.id,
+        ) && entry.path === `.github/workflows/${entry.id}.yml`
       )
     )
       errors.push(
-        `${entry.id}: explicit path is reserved for the build facade and backbone`,
+        `${entry.id}: explicit path is reserved for build APIs and the generated consumer pair`,
       );
     const file = workflowPath(entry);
     if (!WORKFLOW.test(file) || paths.has(file))
@@ -191,35 +193,53 @@ function validateGateIntegration(root, errors) {
     )
   )
     errors.push("required check chain does not enforce check:workflows");
-  const { parse: parseToml } = createRequire(import.meta.url)("smol-toml");
-  const config = parseToml(read(".buildchain/buildchain.toml"));
+  const require = createRequire(import.meta.url);
+  const { parse: parseYaml } = require("yaml");
+  const { compileConsumerPlan } = require("../consumer/contract/plan.js");
+  const { consumerWorkflows } = require("../consumer/contract/entries.js");
+  const config = compileConsumerPlan(read(".buildchain/buildchain.toml"));
+  for (const platform of ["linux-x64", "macos-arm64", "windows-x64"])
+    if (
+      !config.products.some(
+        (product) =>
+          product.platforms.includes(platform) &&
+          product.verify.includes("corepack pnpm@11.7.0 run check") &&
+          product.verify.includes("node scripts/verify-product-platform.mjs"),
+      )
+    )
+      errors.push(
+        `${platform}: declared product verification must execute the full required check and checkpoint recovery`,
+      );
+  const caller = parseYaml(read(".github/workflows/buildchain.yml"));
+  const channel = caller.jobs?.buildchain?.uses?.split("@").at(-1);
+  const configPath = caller.jobs?.buildchain?.with?.["config-path"];
+  for (const [file, expected] of Object.entries(
+    consumerWorkflows(channel, configPath),
+  ))
+    if (read(file) !== expected)
+      errors.push(`${file}: required generated pipeline caller drift`);
+  const execution = parseYaml(
+    read(".github/workflows/.ops-pipeline-execute.yml"),
+  );
+  const build = execution.jobs?.build;
+  const record = execution.jobs?.["record-build"];
   if (
-    !config.lifecycle?.verify?.commands?.includes(
-      "corepack pnpm@11.7.0 run check",
+    build?.permissions?.contents !== "read" ||
+    Object.values(build?.permissions || {}).includes("write") ||
+    !build?.steps?.some(
+      (step) =>
+        step.uses === "./.buildchain/runtime/actions/workflow/pipeline/build",
+    ) ||
+    ![record?.needs].flat().includes("build") ||
+    !record?.steps?.some(
+      (step) =>
+        step.uses ===
+        "./.buildchain/runtime/actions/workflow/pipeline/record-build",
     )
   )
     errors.push(
-      "declared verify lifecycle must execute the full required check",
+      "required product execution and independent source qualification boundary is missing",
     );
-  const verify = read(".github/workflows/self-build-verify.yml");
-  const document = parseWorkflowDocument(verify);
-  for (const trigger of ["pull_request", "merge_group", "push"]) {
-    if (!document.triggers.some((item) => item.split(":")[0] === trigger))
-      errors.push(`required Verify workflow lacks ${trigger}`);
-  }
-  const checkJob = verify.match(/^  check:\n([\s\S]*?)(?=^  [\w-]+:|(?![\s\S]))/mu)?.[1] || "";
-  const verifyNode = "./.buildchain/runtime/actions/build/verification/repository";
-  const verifyAction = read("actions/build/verification/repository/action.yml");
-  const sourceAction = read("actions/build/verification/qualify-source/action.yml");
-  const sourceVerification = read("packages/core/build/verification/source.js");
-  const sourceLifecycle = read("packages/core/build/source/lifecycle.js");
-  if (!parseYamlUses(checkJob).some(call => call.value === verifyNode) ||
-      !parseYamlUses(verifyAction).some(call => call.value === "./.buildchain/runtime/actions/build/verification/qualify-source") ||
-      !/using: node24/u.test(sourceAction) ||
-      !/qualify = qualifySourceLifecycle/u.test(sourceVerification) ||
-      !/mode: "verify"/u.test(sourceVerification) ||
-      !/lifecycle\(\{[\s\S]*stageName,[\s\S]*required: true/u.test(sourceLifecycle))
-    errors.push("required Verify lifecycle integration is missing");
   const owners = read(".github/CODEOWNERS")
     .split(/\r?\n/u)
     .map((line) => line.trim());
@@ -306,7 +326,7 @@ export function renderWorkflowCatalog(policy) {
     "",
     "Public workflows own the consumer API. Component workflows own reusable multi-job topology. Self workflows own Buildchain repository automation. Actions own execution steps; JS adapters and Rust/WASM own implementation.",
     "",
-    "Names use `public-<category>-<purpose>.yml`, `.<category>-<purpose>.yml`, and `self-<category>-<purpose>.yml`, with categories `build`, `release`, and `ops`. The primary build API and backbone use `build.yml` and `.build.yml`.",
+    "Names use `public-<category>-<purpose>.yml`, `.<category>-<purpose>.yml`, and the generated self callers `buildchain.yml` and `buildchain-recover.yml`, with categories `build`, `release`, and `ops`. The primary build API and backbone use `build.yml` and `.build.yml`.",
     "",
     "Register ownership before adding a workflow. `pnpm run check:workflows` validates source, calls, required CI integration and independent review ownership. `pnpm run generate:workflows` regenerates this catalog.",
     "",
@@ -330,22 +350,22 @@ export function renderWorkflowCatalog(policy) {
 }
 
 function validateEntryOwnership(entry, errors) {
-    for (const field of ["summary", "owner", "rationale"])
-      if (typeof entry[field] !== "string" || !entry[field].trim())
-        errors.push(`${entry.id}: missing ${field}`);
-    if (!["active", "preview"].includes(entry.status))
-      errors.push(`${entry.id}: unsupported lifecycle status`);
-    for (const field of ["compatibility", "migration", "retiredAlias"])
-      if (field in entry)
-        errors.push(
-          `${entry.id}: ${field} is not an executable architecture contract`,
-        );
-    if (
-      !["reusable", "dispatch-service", "repository"].includes(entry.invocation)
-    )
-      errors.push(`${entry.id}: invalid invocation`);
-    if ((entry.role === "self") !== (entry.invocation === "repository"))
-      errors.push(`${entry.id}: role and invocation disagree`);
-    if (entry.role === "component" && entry.invocation !== "reusable")
-      errors.push(`${entry.id}: component must be reusable`);
+  for (const field of ["summary", "owner", "rationale"])
+    if (typeof entry[field] !== "string" || !entry[field].trim())
+      errors.push(`${entry.id}: missing ${field}`);
+  if (!["active", "preview"].includes(entry.status))
+    errors.push(`${entry.id}: unsupported lifecycle status`);
+  for (const field of ["compatibility", "migration", "retiredAlias"])
+    if (field in entry)
+      errors.push(
+        `${entry.id}: ${field} is not an executable architecture contract`,
+      );
+  if (
+    !["reusable", "dispatch-service", "repository"].includes(entry.invocation)
+  )
+    errors.push(`${entry.id}: invalid invocation`);
+  if ((entry.role === "self") !== (entry.invocation === "repository"))
+    errors.push(`${entry.id}: role and invocation disagree`);
+  if (entry.role === "component" && entry.invocation !== "reusable")
+    errors.push(`${entry.id}: component must be reusable`);
 }

package/scripts/build-release-discussion-reader.mjs

@@ -10,25 +10,29 @@ try {
   await build({
     entry: {
       "release-discussion": "packages/core/release/discussion/reader-entry.js",
+      "business-attempt": "packages/core/workflow/attempt/reader-entry.js",
     },
     outDir: output,
     format: ["cjs"],
     target: "node24",
     platform: "node",
     splitting: false,
+    noExternal: ["smol-toml"],
     sourcemap: false,
     minify: false,
     clean: false,
     outExtension: () => ({ js: ".cjs" }),
     silent: true,
   });
-  if (
-    check &&
-    !fs
-      .readFileSync(path.join(output, "release-discussion.cjs"))
-      .equals(fs.readFileSync("dist/readers/release-discussion.cjs"))
-  )
-    throw new Error("Historical release reader bundle is stale");
+  if (check)
+    for (const name of ["release-discussion", "business-attempt"]) {
+      if (
+        !fs
+          .readFileSync(path.join(output, `${name}.cjs`))
+          .equals(fs.readFileSync(`dist/readers/${name}.cjs`))
+      )
+        throw new Error(`Historical ${name} reader bundle is stale`);
+    }
 } finally {
   if (check) fs.rmSync(output, { recursive: true, force: true });
 }