@haiyangbg/buildbeat 3.3.0 → 4.0.0

package/src/v2/runtime/overview.js

@@ -16,6 +16,7 @@ import { join } from "node:path";
 import { EventLedger } from "../storage/event-ledger.js";
 import { latestAdjudications, readFindingsAccount } from "./findings.js";
 import { nextReply } from "./notify.js";
+import { readReleases } from "./release.js";
 import { computeWorkCost, renderWorkCost } from "./work-cost.js";
 
 function sha256File(path) {
@@ -45,18 +46,31 @@ export function artifactStatus(workDir, decisions, artifact) {
     return { exists: false, accepted: false, stale: false };
   }
   const digest = sha256File(path);
-  const accepts = decisions.filter((row) => row.transition === `accept-${artifact}` && row.decision === "approved");
+  const accepts = decisions.filter(
+    (row) =>
+      row.transition === `accept-${artifact}` && row.decision === "approved",
+  );
   const latest = accepts[accepts.length - 1];
   if (!latest) {
     return { exists: true, accepted: false, stale: false };
   }
   const stale = latest.subject?.digest !== digest;
-  return { exists: true, accepted: !stale, stale, by: latest.by, at: latest.ts };
+  return {
+    exists: true,
+    accepted: !stale,
+    stale,
+    by: latest.by,
+    at: latest.ts,
+  };
 }
 
 function isAncestor(repoRoot, sha, ref) {
   try {
-    execFileSync("git", ["-C", repoRoot, "merge-base", "--is-ancestor", sha, ref], { stdio: "ignore" });
+    execFileSync(
+      "git",
+      ["-C", repoRoot, "merge-base", "--is-ancestor", sha, ref],
+      { stdio: "ignore" },
+    );
     return true;
   } catch {
     return false;
@@ -65,14 +79,18 @@ function isAncestor(repoRoot, sha, ref) {
 
 function headRef(repoRoot) {
   try {
-    return execFileSync("git", ["-C", repoRoot, "rev-parse", "--abbrev-ref", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    return execFileSync(
+      "git",
+      ["-C", repoRoot, "rev-parse", "--abbrev-ref", "HEAD"],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] },
+    ).trim();
   } catch {
     return "HEAD";
   }
 }
 
 // Runs for a work: runtime ledgers first, run-records for the rest.
-function runsFor(repoRoot, workId) {
+export function runsFor(repoRoot, workId) {
   const runs = new Map();
   const runsDir = join(repoRoot, ".buildbeat", "runtime", "runs");
   if (existsSync(runsDir)) {
@@ -131,10 +149,15 @@ function runsFor(repoRoot, workId) {
       }
     }
   }
-  return [...runs.values()].sort((a, b) => String(a.createdAt).localeCompare(String(b.createdAt)));
+  return [...runs.values()].sort((a, b) =>
+    String(a.createdAt).localeCompare(String(b.createdAt)),
+  );
 }
 
-export function computeOverview(repoRoot, { work = null, repoLabel = "." } = {}) {
+export function computeOverview(
+  repoRoot,
+  { work = null, repoLabel = "." } = {},
+) {
   const workRoot = join(repoRoot, "delivery", "work");
   const rows = [];
   if (!existsSync(workRoot)) {
@@ -146,17 +169,31 @@ export function computeOverview(repoRoot, { work = null, repoLabel = "." } = {})
       continue;
     }
     const workDir = join(workRoot, workId);
-    if (!existsSync(join(workDir, "intent.md")) && !existsSync(join(workDir, "plan.md")) && !existsSync(join(workDir, "decisions.jsonl")) && !existsSync(join(workDir, "runs"))) {
+    if (
+      !existsSync(join(workDir, "work.md")) &&
+      !existsSync(join(workDir, "intent.md")) &&
+      !existsSync(join(workDir, "plan.md")) &&
+      !existsSync(join(workDir, "decisions.jsonl")) &&
+      !existsSync(join(workDir, "runs"))
+    ) {
       continue;
     }
     const decisions = readJsonl(join(workDir, "decisions.jsonl"));
-    const intent = artifactStatus(workDir, decisions, "intent");
-    const plan = artifactStatus(workDir, decisions, "plan");
+    const unified = existsSync(join(workDir, "work.md"));
+    const intent = artifactStatus(
+      workDir,
+      decisions,
+      unified ? "work" : "intent",
+    );
+    const plan = unified ? intent : artifactStatus(workDir, decisions, "plan");
     const envFacts = existsSync(join(workDir, "env-facts.md"));
     const findingRows = readFindingsAccount(repoRoot, workId);
     const adjudicated = latestAdjudications(findingRows);
     const openFindings = findingRows.filter(
-      (row) => row.kind === "finding" && (row.severity === "P0" || row.severity === "P1") && !adjudicated.has(row.fingerprint),
+      (row) =>
+        row.kind === "finding" &&
+        (row.severity === "P0" || row.severity === "P1") &&
+        !adjudicated.has(row.fingerprint),
     ).length;
     const runs = runsFor(repoRoot, workId);
     const live = runs.filter((run) => run.status !== "SUPERSEDED");
@@ -166,28 +203,44 @@ export function computeOverview(repoRoot, { work = null, repoLabel = "." } = {})
     // (its in-run review budget ran out and closure happened elsewhere) and
     // overview reported the shipped work as STOPPED_CANCELLED.
     const mergedRun =
-      [...runs].reverse().find((run) => run.candidate && isAncestor(repoRoot, run.candidate, mainRef)) ?? null;
+      [...runs]
+        .reverse()
+        .find(
+          (run) =>
+            run.candidate && isAncestor(repoRoot, run.candidate, mainRef),
+        ) ?? null;
     const merged = Boolean(mergedRun);
     const RELEASE_STEPS = ["preflight", "apply-readback", "observe"];
     const isReleaseLane = (run) =>
-      Boolean(run) && (run.workflow === "release-readback" || run.steps.some((step) => RELEASE_STEPS.includes(step)));
+      Boolean(run) &&
+      (run.workflow === "release-readback" ||
+        run.steps.some((step) => RELEASE_STEPS.includes(step)));
 
     // A Work is closed by an explicit row in decisions.jsonl:
     //   {"transition":"close-work","decision":"closed"|"cancelled","subject":{"result":"..."}}
     // A live run (RUNNING / WAITING_HUMAN) contradicts a closure and wins, so a
     // stale close row can never hide something that still needs a human.
-    const closure = [...decisions].reverse().find((row) => row.transition === "close-work");
-    const liveRun = latest && (latest.status === "RUNNING" || latest.status === "WAITING_HUMAN");
+    const closure = [...decisions]
+      .reverse()
+      .find((row) => row.transition === "close-work");
+    const readback = readReleases(repoRoot, workId).at(-1) ?? null;
+    const liveRun =
+      latest &&
+      (latest.status === "RUNNING" || latest.status === "WAITING_HUMAN");
 
     let stage;
     let next;
     if (closure && !liveRun) {
       stage = closure.decision === "cancelled" ? "CANCELLED" : "CLOSED";
-      const result = typeof closure.subject?.result === "string" && closure.subject.result.length > 0 ? closure.subject.result : "see decisions.jsonl";
+      const result =
+        typeof closure.subject?.result === "string" &&
+        closure.subject.result.length > 0
+          ? closure.subject.result
+          : "see decisions.jsonl";
       next = `${stage.toLowerCase()} @ ${closure.ts ?? "?"}: ${result.slice(0, 160)}`;
     } else if (!intent.exists) {
       stage = "NO_INTENT";
-      next = `write delivery/work/${workId}/intent.md (what and why), then plan.md`;
+      next = `write delivery/work/${workId}/work.md (goal, scope, acceptance, implementation plan)`;
     } else if (!latest) {
       if (!plan.exists) {
         stage = intent.accepted ? "INTENT_ACCEPTED" : "INTENT_DRAFT";
@@ -195,23 +248,40 @@ export function computeOverview(repoRoot, { work = null, repoLabel = "." } = {})
           ? `write delivery/work/${workId}/plan.md, then accept it`
           : `buildbeat accept --repo ${repoLabel} --work ${workId} --artifact intent --by <you>`;
       } else if (!plan.accepted) {
-        stage = plan.stale ? "PLAN_STALE" : "PLAN_DRAFT";
-        const artifacts = intent.accepted ? "plan" : "intent,plan";
-        next = `buildbeat accept --repo ${repoLabel} --work ${workId} --artifact ${artifacts} --by <you>${plan.stale ? "   # plan changed since acceptance" : ""}`;
+        stage = unified
+          ? plan.stale
+            ? "WORK_STALE"
+            : "WORK_DRAFT"
+          : plan.stale
+            ? "PLAN_STALE"
+            : "PLAN_DRAFT";
+        const artifacts = unified
+          ? "work"
+          : intent.accepted
+            ? "plan"
+            : "intent,plan";
+        next = `buildbeat accept --repo ${repoLabel} --work ${workId} --artifact ${artifacts} --by <you>${plan.stale ? `   # ${unified ? "work.md" : "plan"} changed since acceptance` : ""}`;
       } else {
         stage = "READY_TO_RUN";
-        const configs = readdirSync(workDir).filter((name) => /^run-config.*\.ya?ml$/.test(name));
+        const configs = readdirSync(workDir).filter((name) =>
+          /^run-config.*\.ya?ml$/.test(name),
+        );
         next =
           configs.length > 0
-            ? `buildbeat start --config delivery/work/${workId}/${configs[0]} --attempt new`
+            ? `buildbeat run --config delivery/work/${workId}/${configs[0]}`
             : `no run-config in delivery/work/${workId}: write one, or close it with a decisions.jsonl row {"transition":"close-work","decision":"closed","subject":{"result":"..."}} if it was doc-only`;
       }
     } else if (latest.status === "RUNNING") {
       stage = "RUNNING";
       next = `buildbeat status --repo ${repoLabel} --run ${latest.id}`;
     } else if (latest.status === "WAITING_HUMAN") {
-      stage = latest.pendingHuman?.kind === "final-decision" ? "MERGE_DECISION" : "WAITING_HUMAN";
-      const replies = latest.state ? nextReply({ repoLabel, state: latest.state }) : [];
+      stage =
+        latest.pendingHuman?.kind === "final-decision"
+          ? "MERGE_DECISION"
+          : "WAITING_HUMAN";
+      const replies = latest.state
+        ? nextReply({ repoLabel, state: latest.state })
+        : [];
       next = replies[0] ?? `buildbeat inbox --repo ${repoLabel}`;
     } else if (latest.status === "SUCCEEDED" && isReleaseLane(latest)) {
       // A release-readback lane that reached wait-close and was approved is
@@ -220,9 +290,23 @@ export function computeOverview(repoRoot, { work = null, repoLabel = "." } = {})
       next = `release window closed by ${latest.id}; close the work with a decisions.jsonl row {"transition":"close-work","decision":"closed","subject":{"result":"released"}}`;
     } else if (merged) {
       stage = "MERGED";
-      next =
-        `candidate ${mergedRun.candidate.slice(0, 7)} (${mergedRun.id}) is on ${mainRef}; release/deploy stays a human action; then buildbeat gc --repo ${repoLabel}` +
-        (latest.status !== "SUCCEEDED" ? `   # latest run ${latest.id} ended ${latest.status} after the merge` : "");
+      // After the merge: the person releases, the project's readback proves
+      // it, and the window closes on a passing readback.
+      const configs = readdirSync(workDir).filter((name) =>
+        /^run-config.*\.ya?ml$/.test(name),
+      );
+      const config = configs.length
+        ? `delivery/work/${workId}/${configs[0]}`
+        : "<run-config.yaml>";
+      const close = `buildbeat decide --repo ${repoLabel} --work ${workId} --action close --result <what was released> --by <you>`;
+      next = !readback
+        ? `candidate ${mergedRun.candidate.slice(0, 7)} (${mergedRun.id}) is on ${mainRef}; release it (a human action), then buildbeat release --config ${config}; then ${close}`
+        : readback.status === "passed"
+          ? `readback passed @ ${readback.ts} (${readback.commit.slice(0, 7)}); close the window: ${close}`
+          : `latest readback failed @ ${readback.ts} (exit ${readback.exitCode}); fix the release, then buildbeat release --config ${config} again`;
+      if (latest.status !== "SUCCEEDED") {
+        next += `   # latest run ${latest.id} ended ${latest.status} after the merge`;
+      }
     } else if (latest.status === "SUCCEEDED") {
       stage = "MERGE_READY";
       next = latest.candidate
@@ -231,23 +315,49 @@ export function computeOverview(repoRoot, { work = null, repoLabel = "." } = {})
     } else {
       stage = `STOPPED_${latest.status}`;
       next = plan.accepted
-        ? `decide: retry (buildbeat start ... --attempt new) or close the work`
-        : `plan not accepted (${plan.exists ? "draft" : "missing"}); fix that before another run`;
+        ? `decide: retry (buildbeat run --config <run-config.yaml> --new) or close the work`
+        : `${unified ? "work.md" : "plan"} not accepted (${plan.exists ? "draft" : "missing"}); fix that before another run`;
     }
     rows.push({
       work: workId,
       stage,
       intent,
       plan,
+      ...(unified ? { workArtifact: "work" } : {}),
       envFacts,
       openFindings,
+      findings: findingRows
+        .filter((item) => item.kind === "finding")
+        .map((item) => ({
+          ...item,
+          adjudication: adjudicated.get(item.fingerprint)?.action ?? "open",
+        })),
       runs: runs.length,
       cost: runs.length > 0 ? computeWorkCost(repoRoot, workId) : null,
       latest: latest
-        ? { id: latest.id, status: latest.status, candidate: latest.candidate, at: latest.lastAt, source: latest.source, terminalReason: latest.terminal?.reason ?? null, waiting: latest.pendingHuman?.transition ?? null }
+        ? {
+            id: latest.id,
+            status: latest.status,
+            candidate: latest.candidate,
+            at: latest.lastAt,
+            source: latest.source,
+            terminalReason: latest.terminal?.reason ?? null,
+            waiting: latest.pendingHuman?.transition ?? null,
+          }
         : null,
       merged,
       mergedCandidate: mergedRun?.candidate ?? null,
+      ...(readback
+        ? {
+            readback: {
+              status: readback.status,
+              at: readback.ts,
+              commit: readback.commit,
+              digest: readback.digest,
+              ...(readback.note ? { note: readback.note } : {}),
+            },
+          }
+        : {}),
       next,
     });
   }
@@ -271,14 +381,29 @@ export function renderOverview(rows) {
   const lines = [];
   for (const row of rows) {
     lines.push(`${row.work}  ${row.stage}`);
-    const parts = [`intent ${mark(row.intent)}`, `plan ${mark(row.plan)}`, `runs ${row.runs}`];
-    const settled = ["MERGED", "RELEASED", "CLOSED", "CANCELLED"].includes(row.stage);
+    const parts =
+      row.workArtifact === "work"
+        ? [`work.md ${mark(row.plan)}`, `runs ${row.runs}`]
+        : [
+            `intent ${mark(row.intent)}`,
+            `plan ${mark(row.plan)}`,
+            `runs ${row.runs}`,
+          ];
+    const settled = ["MERGED", "RELEASED", "CLOSED", "CANCELLED"].includes(
+      row.stage,
+    );
     if (row.openFindings > 0 && !settled) {
       // Unadjudicated, not necessarily unresolved: a fixer may have closed
       // them without anyone recording a verdict. The number says "nobody
       // ruled on these", which is exactly what a human should know.
       parts.push(`unadjudicated P0/P1 findings ${row.openFindings}`);
     }
+    if (!settled && row.findings?.length) {
+      for (const finding of row.findings)
+        lines.push(
+          `  [${finding.severity} ${finding.fingerprint}] (${finding.adjudication}) ${finding.summary}`,
+        );
+    }
     if (row.envFacts) {
       parts.push("env-facts ✓");
     }
@@ -293,8 +418,12 @@ export function renderOverview(rows) {
         ? ` candidate ${row.latest.candidate.slice(0, 7)}${row.latest.candidate === row.mergedCandidate ? " (merged)" : ""}`
         : "";
       const wait = row.latest.waiting ? ` waiting ${row.latest.waiting}` : "";
-      const why = row.latest.terminalReason ? ` — ${row.latest.terminalReason.slice(0, 100)}` : "";
-      lines.push(`  latest ${row.latest.id} ${row.latest.status}${cand}${wait} @ ${row.latest.at ?? "?"}${why}`);
+      const why = row.latest.terminalReason
+        ? ` — ${row.latest.terminalReason.slice(0, 100)}`
+        : "";
+      lines.push(
+        `  latest ${row.latest.id} ${row.latest.status}${cand}${wait} @ ${row.latest.at ?? "?"}${why}`,
+      );
     }
     lines.push(`  next: ${row.next}`);
   }

package/src/v2/runtime/release.js

@@ -0,0 +1,233 @@
+// Release readback and closeout (4.0; replaces the retired release-readback
+// lane, owner decision 2026-10-04). BuildBeat still performs no deployment
+// (invariant 20): after a person releases a merged candidate, the project's
+// own read-only command proves the release took effect. Every readback is a
+// line in the Work's releases.jsonl, next to its decisions, and the window
+// closes only on a passing readback. Real cost behind it: one pilot go-live
+// was recorded by hand as forty "step N readback" commits.
+
+import { execFileSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import { createShellAdapter } from "../adapters/shell.js";
+import { toRepoRef } from "./repo-ref.js";
+
+const TAIL_LINES = 20;
+
+export class ReleaseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ReleaseError";
+  }
+}
+
+function workDir(repoRoot, workId) {
+  return join(repoRoot, "delivery", "work", workId);
+}
+
+function readRows(path) {
+  if (!existsSync(path)) {
+    return [];
+  }
+  return readFileSync(path, "utf8")
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+export function readReleases(repoRoot, workId) {
+  return readRows(join(workDir(repoRoot, workId), "releases.jsonl"));
+}
+
+function isAncestor(repoRoot, sha, commit) {
+  try {
+    execFileSync(
+      "git",
+      ["-C", repoRoot, "merge-base", "--is-ancestor", sha, commit],
+      { stdio: "ignore" },
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Runs the configured readback in the main checkout once and records it.
+// `runs` are the Work's runs (overview's runsFor); the newest SUCCEEDED one
+// whose candidate the release ref contains is what this readback is about.
+export function runReadback({
+  repoRoot,
+  workId,
+  spec,
+  redact = [],
+  runs,
+  ref = "HEAD",
+  note = null,
+  ts = new Date().toISOString(),
+}) {
+  const resolveCommit = (name) =>
+    execFileSync(
+      "git",
+      ["-C", repoRoot, "rev-parse", "--verify", `${name}^{commit}`],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] },
+    ).trim();
+  let commit;
+  try {
+    commit = resolveCommit(ref);
+  } catch {
+    throw new ReleaseError(`--ref ${ref} does not name a commit`);
+  }
+  // The command runs in the main checkout, which may sit elsewhere than the
+  // released ref; both are recorded so neither is claimed for the other.
+  const checkout = resolveCommit("HEAD");
+  const succeeded = runs
+    .filter((run) => run.status === "SUCCEEDED" && run.candidate)
+    .sort((a, b) => String(a.lastAt).localeCompare(String(b.lastAt)));
+  if (succeeded.length === 0) {
+    throw new ReleaseError(
+      `${workId} has no succeeded run; approve its merge decision first`,
+    );
+  }
+  const released = [...succeeded]
+    .reverse()
+    .find((run) => isAncestor(repoRoot, run.candidate, commit));
+  if (!released) {
+    const latest = succeeded.at(-1);
+    throw new ReleaseError(
+      `candidate ${latest.candidate.slice(0, 7)} (${latest.id}) is not contained in ${ref} (${commit.slice(0, 7)}); merge it first`,
+    );
+  }
+
+  const adapter = createShellAdapter({
+    name: "shell:release",
+    command: spec.command,
+    args: spec.args ?? [],
+    timeoutMs: spec.timeoutMs,
+    inheritEnv: spec.inheritEnv === true,
+    env: spec.env ?? {},
+  });
+  const exec = adapter.execute({
+    step: "release",
+    worker: "release",
+    workspacePath: repoRoot,
+    input: { workId, run: released.id, candidate: released.candidate, ref, commit },
+  });
+  const scrub = (text) => {
+    let out = String(text ?? "");
+    for (const pattern of redact) {
+      out = out.replace(pattern, "<REDACTED>");
+    }
+    return out;
+  };
+  const output = [scrub(exec.stdout), scrub(exec.stderr)]
+    .filter((text) => text.length > 0)
+    .join("\n");
+  const body = [
+    `command: ${scrub(exec.command)}`,
+    `exitCode: ${exec.exitCode}`,
+    `signal: ${exec.signal}`,
+    `timedOut: ${exec.timedOut}`,
+    `spawnError: ${exec.spawnError}`,
+    "--- stdout ---",
+    scrub(exec.stdout),
+    "--- stderr ---",
+    scrub(exec.stderr),
+  ].join("\n");
+  const logDir = join(repoRoot, ".buildbeat", "runtime", "releases", workId);
+  mkdirSync(logDir, { recursive: true });
+  // Unique per readback: concurrent readbacks never share a log file.
+  const logPath = join(
+    logDir,
+    `release-${ts.replace(/[^0-9A-Za-z]/g, "")}-${randomUUID().slice(0, 8)}.log`,
+  );
+  writeFileSync(logPath, body, { encoding: "utf8", flag: "wx" });
+  const passed =
+    exec.exitCode === 0 && !exec.timedOut && !exec.signal && !exec.spawnError;
+  const row = {
+    ts,
+    work: workId,
+    run: released.id,
+    candidate: released.candidate,
+    ref,
+    commit,
+    checkout,
+    ...(note ? { note } : {}),
+    command: scrub(exec.command),
+    exitCode: exec.exitCode,
+    status: passed ? "passed" : "failed",
+    grade: "L4",
+    digest: `sha256:${createHash("sha256").update(body, "utf8").digest("hex")}`,
+    log: toRepoRef(repoRoot, logPath),
+    tail: output.split("\n").filter(Boolean).slice(-TAIL_LINES),
+  };
+  mkdirSync(workDir(repoRoot, workId), { recursive: true });
+  appendFileSync(
+    join(workDir(repoRoot, workId), "releases.jsonl"),
+    `${JSON.stringify(row)}\n`,
+    "utf8",
+  );
+  return row;
+}
+
+// Closes the release window: a close-work decision bound to the latest
+// readback, which must have passed.
+export function closeWork({
+  repoRoot,
+  workId,
+  result,
+  by = "human",
+  ts = new Date().toISOString(),
+}) {
+  if (typeof result !== "string" || result.trim() === "") {
+    throw new ReleaseError("closing a work needs --result <text>");
+  }
+  const decisionsPath = join(workDir(repoRoot, workId), "decisions.jsonl");
+  const decisions = readRows(decisionsPath);
+  if (decisions.some((row) => row.transition === "close-work")) {
+    throw new ReleaseError(`${workId} is already closed`);
+  }
+  const latest = readReleases(repoRoot, workId).at(-1);
+  if (!latest) {
+    throw new ReleaseError(
+      `${workId} has no readback; run buildbeat release --config <run-config.yaml> after the release first`,
+    );
+  }
+  if (latest.status !== "passed") {
+    throw new ReleaseError(
+      `the latest readback failed (exit ${latest.exitCode} at ${latest.ts}); fix the release and run buildbeat release again before closing`,
+    );
+  }
+  const count = existsSync(decisionsPath)
+    ? readFileSync(decisionsPath, "utf8").split("\n").filter(Boolean).length
+    : 0;
+  const row = {
+    ts,
+    decisionRef: `C-${workId}-${count + 1}`,
+    decision: "closed",
+    transition: "close-work",
+    subject: {
+      result: result.trim(),
+      readback: latest.digest,
+      commit: latest.commit,
+      candidate: latest.candidate,
+    },
+    by,
+  };
+  appendFileSync(decisionsPath, `${JSON.stringify(row)}\n`, "utf8");
+  return row;
+}

package/src/v2/runtime/run-record.js

@@ -42,6 +42,7 @@ export function writeRunRecord({ repoRoot, ledger, ts }) {
     run: first.run,
     work: first.work,
     workflow: state.run?.workflowRef ?? null,
+    ...(state.run?.deliveryChecks ? { deliveryChecks: state.run.deliveryChecks } : {}),
     terminal: state.terminal,
     events: { from: first.seq, to: last.seq, lastDigest: last.digest },
     startedAt: first.ts,

package/src/v2/workspace/workspace-manager.js

@@ -374,6 +374,14 @@ export function pinCandidate(workspace) {
   return head;
 }
 
+// Undoes createWorkspace for a run that never started (nothing was written
+// to its ledger): the worktree and its branch both go, so the same run id
+// can be created again.
+export function discardWorkspace(workspace) {
+  git(workspace.repoRoot, ["worktree", "remove", "--force", workspace.worktreePath]);
+  git(workspace.repoRoot, ["branch", "-D", workspace.branch]);
+}
+
 export function removeWorkspace(workspace, { force = false } = {}) {
   const { dirty } = readback(workspace.worktreePath);
   if (dirty && !force) {