@intentius/chant 0.124.27 → 0.124.29

package/src/workspace/status-gates.ts

@@ -25,6 +25,14 @@ import type { GateResolutionRecord, PendingGateRecord } from "../lifecycle/gate-
 import { isPendingGateExpired, latestPendingGate, latestResolutionForPlan, parseGateLedger } from "../lifecycle/gate-ledger";
 import { humanQuorumSince, tallyGateApprovals, type GateApprovalRule } from "../op/gate";
 import type { ReasonCode } from "./reason-codes";
+import type { ReleaseRevocation } from "../lifecycle/release-revocation";
+import { CHANGE_SETS_DIR, changeSetFile } from "../lifecycle/change-set-store";
+
+/** The stored change-set directory beside a gate ledger directory: `<prefix>_change-sets`. */
+function changeSetDirFor(gatesDir: string): string {
+  const at = gatesDir.lastIndexOf("/");
+  return at < 0 ? CHANGE_SETS_DIR : `${gatesDir.slice(0, at)}/${CHANGE_SETS_DIR}`;
+}
 
 /** Why a member's gates can't be listed. Closed: a new code is a contract change. */
 export const GATE_REASON_CODES = [
@@ -58,9 +66,34 @@ export interface StatusGate {
   env: string | null;
   /** The plan the run reached the gate with, or null for a gate that binds no plan. */
   planDigest: string | null;
+  /**
+   * The release the gate binds (#4045), from the pending fact: on a release
+   * gate, the one `chant components promote --release` passes, recorded
+   * under the op `release`. Absent on every other gate and on a fact written
+   * before chant 0.124.28.
+   */
+  releaseDigest?: string;
   state: GateState;
+  /**
+   * Set on a release gate whose release was cut from a revoked commit
+   * (#4033, ws-105): the revoked tag on that commit. The gate is then
+   * `superseded` (or `expired`), and `chant approve` refuses it with
+   * `release-revoked`. Added by `workspace status`; absent otherwise.
+   */
+  revoked?: ReleaseRevocation;
   /** When the run recorded the pending fact the state is read against. */
   recordedAt: string;
+  /** The commit the run reached the gate at (#4020), from the pending fact. Absent on a fact written before chant 0.124.28. */
+  gitSha?: string;
+  /** The run that reached the gate (#4020), from the pending fact: an Op run id, or the CI run id. Absent when the run had none. */
+  runId?: string;
+  /**
+   * The change set the gate binds (#4022): `planDigest`, when a change-set
+   * document is stored under it in the member's `_change-sets/`, read with
+   * `chant change-set show <digest>`. Absent when none is stored, as for a
+   * component gate, which binds a lifecycle-plan digest.
+   */
+  changeSet?: string;
   expiresAt: string;
   /** The approvals that count toward the gate for this plan, oldest first. */
   approvals: StatusGateApproval[];
@@ -113,6 +146,21 @@ function git(cwd: string, args: string[]): string {
   return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 64 * 1024 * 1024 });
 }
 
+/**
+ * Lists the file names in a stored change-set directory on the branch at
+ * `commit`, or an empty set when it doesn't exist or can't be read: a gate
+ * then shows no link, and its state is read the same.
+ */
+export type ChangeSetLister = (dir: string, commit: string, cwd: string) => Promise<Set<string>>;
+
+export const defaultChangeSetLister: ChangeSetLister = async (dir, commit, cwd) => {
+  try {
+    return new Set(git(cwd, ["ls-tree", "--name-only", `${commit}:${dir}`]).split("\n").filter(Boolean));
+  } catch {
+    return new Set();
+  }
+};
+
 export const defaultGateLedgerReader: GateLedgerReader = async (dir, commit, cwd) => {
   try {
     git(cwd, ["rev-parse", "--verify", "--quiet", `${commit}:${dir}`]);
@@ -143,7 +191,10 @@ const approvalOf = (r: GateResolutionRecord): StatusGateApproval => ({ principal
 function decide(component: string, standing: PendingGateRecord, facts: PendingGateRecord[], all: GateResolutionRecord[], now: string, rule: GateApprovalRule | null): StatusGate {
   const gate = standing.gate;
   // #3163: under identity.gates, an unsigned approval, or one from outside the class, doesn't count, as a run reads it.
-  const resolutions = rule === null ? all : all.filter((r) => r.gate !== gate || rule.refuses(r) === null);
+  // #4045: nor does an approval for another release, and an `empty` pass is never an approval.
+  const resolutions = all
+    .filter((r) => r.gate !== gate || (r.empty !== true && r.releaseDigest === standing.releaseDigest))
+    .filter((r) => rule === null || r.gate !== gate || rule.refuses(r) === null);
   const env = standing.environment ?? null;
   const since = standing.timestamp;
   const planDigest = standing.planDigest;
@@ -177,8 +228,11 @@ function decide(component: string, standing: PendingGateRecord, facts: PendingGa
     name: gate,
     env,
     planDigest: planDigest ?? null,
+    ...(standing.releaseDigest !== undefined ? { releaseDigest: standing.releaseDigest } : {}),
     state,
     recordedAt: standing.timestamp,
+    ...(standing.gitSha ? { gitSha: standing.gitSha } : {}),
+    ...(standing.runId ? { runId: standing.runId } : {}),
     expiresAt: standing.expiresAt,
     approvals: approvals.map(approvalOf),
     needed,
@@ -226,6 +280,7 @@ export async function readMemberGates(
   now: string,
   read: GateLedgerReader = defaultGateLedgerReader,
   rules: GateRuleLookup = () => null,
+  listChangeSets: ChangeSetLister = defaultChangeSetLister,
 ): Promise<{ gates: StatusGate[]; ledger: StatusGateLedger }> {
   const ledger: StatusGateLedger = { layout, path: dir, shared: false, malformed: 0, reason: null };
   if (commit === null) {
@@ -247,5 +302,13 @@ export async function readMemberGates(
     gates.push(...read.gates);
     ledger.malformed += read.malformed;
   }
+  // #4022: link each gate to the change set stored under its plan digest,
+  // in the same member's `_change-sets/` beside `_gates/`.
+  if (gates.some((g) => g.planDigest !== null)) {
+    const stored = await listChangeSets(changeSetDirFor(dir), commit, cwd);
+    for (const g of gates) {
+      if (g.planDigest !== null && stored.has(changeSetFile(g.planDigest))) g.changeSet = g.planDigest;
+    }
+  }
   return { gates, ledger };
 }

package/src/workspace/status-mixed.test.ts

@@ -0,0 +1,152 @@
+/**
+ * #4035: an environment a promote left mixed, as `workspace status --json`
+ * shows it: what each component runs, and the redeploy and rollback lines
+ * that settle it. Against temp repos; nothing is pushed.
+ */
+
+import { describe, expect, test } from "vitest";
+import { withTestDir } from "@intentius/chant-test-utils";
+import { spawnSync } from "node:child_process";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Ajv2020 } from "ajv/dist/2020";
+import statusSchema from "./status.schema.json";
+import { formatStatus, workspaceStatus, type StatusDocument } from "./status";
+import { appendCut, makeRelease, persistRelease, type Release } from "../lifecycle/release-store";
+import { appendReleaseRecord, type ReleaseRecordInput } from "../lifecycle/release-ledger";
+import { appendDeployOutcome } from "../lifecycle/deploy-outcome";
+import { contentDigest } from "../content-digest";
+
+const validateStatus = new Ajv2020({ strict: true, allErrors: true }).compile(statusSchema);
+const NOW = "2026-10-17T14:00:00.000Z";
+
+function git(cwd: string, ...args: string[]): string {
+  const r = spawnSync("git", args, { cwd, encoding: "utf-8" });
+  if (r.status !== 0) throw new Error(`git ${args.join(" ")}: ${r.stderr}`);
+  return r.stdout.trim();
+}
+
+function result(doc: StatusDocument): Extract<StatusDocument, { members: unknown }> {
+  if ("error" in doc) throw new Error(`${doc.error.code}: ${doc.error.message}`);
+  expect(validateStatus(doc), JSON.stringify(validateStatus.errors, null, 2)).toBe(true);
+  return doc;
+}
+
+/** A workspace whose root member has releases v1.0.0 and v1.1.0 of api and web, and runs v1.0.0 in prod. */
+async function setup(dir: string): Promise<{ v1: Release; v2: Release; deploy: (input: Partial<ReleaseRecordInput> & { component: string; timestamp: string; releaseDigest: string }) => Promise<void> }> {
+  git(dir, "init", "-q", "-b", "main");
+  git(dir, "config", "user.email", "t@chant.dev");
+  git(dir, "config", "user.name", "T");
+  writeFileSync(
+    join(dir, "chant.workspace.json"),
+    JSON.stringify({ name: "acme", schema: 1, members: [{ name: "root", dir: ".", kind: "other", because: "the fixture" }] }, null, 2),
+  );
+  git(dir, "add", ".");
+  git(dir, "commit", "-q", "-m", "init");
+  const first = git(dir, "rev-parse", "HEAD");
+  git(dir, "commit", "-q", "--allow-empty", "-m", "next");
+  const second = git(dir, "rev-parse", "HEAD");
+  const at = (commit: string) =>
+    makeRelease({
+      member: null,
+      commit,
+      artifactDigests: ["api", "web"].map((component) => ({ component, kind: "image" as const, path: `${component}.tar`, digest: contentDigest(`${component} ${commit}`) })),
+      targets: [{ env: "prod", templates: [], params: [] }],
+    });
+  const v1 = at(first);
+  const v2 = at(second);
+  for (const [r, label, ts] of [[v1, "v1.0.0", "10"], [v2, "v1.1.0", "11"]] as const) {
+    await persistRelease(r, [], { cwd: dir });
+    await appendCut({ releaseDigest: r.releaseDigest, label, actor: "alice", timestamp: `2026-10-17T${ts}:00:00.000Z`, runOrigin: null }, { cwd: dir });
+  }
+  const deploy = async (input: Partial<ReleaseRecordInput> & { component: string; timestamp: string; releaseDigest: string }) => {
+    await appendReleaseRecord(
+      { env: "prod", digest: contentDigest(`${input.component} ${input.releaseDigest}`), gitSha: first, runId: "r", actor: "ci", ...input },
+      { cwd: dir },
+    );
+  };
+  for (const component of ["api", "web"]) await deploy({ component, timestamp: "2026-10-17T12:00:00.000Z", releaseDigest: v1.releaseDigest });
+  return { v1, v2, deploy };
+}
+
+describe("a mixed environment in workspace status (#4035)", () => {
+  test("a partly applied promote shows the environment mixed, with the redeploy and rollback lines, until it is settled", async () => {
+    await withTestDir(async (dir) => {
+      const { v1, v2, deploy } = await setup(dir);
+
+      // Before the promote: one release, nothing mixed.
+      const before = result(await workspaceStatus({ cwd: dir, env: "prod", now: NOW }));
+      expect(before.members[0].environments[0]).not.toHaveProperty("mixed");
+
+      // The promote of v1.1.0 deploys api and fails on web.
+      const at = "2026-10-17T13:00:00.000Z";
+      await deploy({ component: "api", timestamp: at, releaseDigest: v2.releaseDigest, runId: "run-9", promotedFrom: { env: "staging", runId: "run-8", timestamp: "2026-10-17T12:30:00.000Z" } });
+      await appendDeployOutcome(
+        {
+          version: 1, env: "prod", verb: "promote", runId: "run-9", timestamp: at, actor: "bob", releaseDigest: v2.releaseDigest, status: "fail",
+          components: [
+            { component: "api", outcome: "deployed", digest: contentDigest(`api ${v2.releaseDigest}`), releaseDigest: v2.releaseDigest },
+            { component: "web", outcome: "failed", digest: contentDigest(`web ${v2.releaseDigest}`), releaseDigest: v2.releaseDigest },
+          ],
+        },
+        { cwd: dir },
+      );
+
+      const doc = result(await workspaceStatus({ cwd: dir, env: "prod", now: NOW }));
+      const prod = doc.members[0].environments[0];
+      expect(prod.mixed).toEqual({
+        components: [
+          { component: "api", digest: contentDigest(`api ${v2.releaseDigest}`), releaseDigest: v2.releaseDigest, releaseLabel: "v1.1.0", state: "settled", attempt: null },
+          {
+            component: "web",
+            digest: contentDigest(`web ${v1.releaseDigest}`),
+            releaseDigest: v1.releaseDigest,
+            releaseLabel: "v1.0.0",
+            state: "failed",
+            attempt: { verb: "promote", runId: "run-9", timestamp: at, digest: contentDigest(`web ${v2.releaseDigest}`), releaseDigest: v2.releaseDigest, releaseLabel: "v1.1.0" },
+          },
+        ],
+        redeploy: ["chant components redeploy prod --component web"],
+        rollback: "chant components rollback prod --release v1.0.0",
+      });
+      expect(formatStatus(doc)).toContain("  prod is mixed: api runs release v1.1.0; web failed (promote run-9), recorded release v1.0.0");
+      expect(formatStatus(doc)).toContain("    redeploy: chant components redeploy prod --component web");
+      expect(formatStatus(doc)).toContain("    roll back: chant components rollback prod --release v1.0.0");
+
+      // A redeploy of web settles it, but prod still runs two releases.
+      await deploy({ component: "web", timestamp: "2026-10-17T13:10:00.000Z", releaseDigest: v1.releaseDigest, redeploys: { env: "prod", runId: "r", timestamp: "2026-10-17T12:00:00.000Z" } });
+      const redeployed = result(await workspaceStatus({ cwd: dir, env: "prod", now: NOW })).members[0].environments[0];
+      expect(redeployed.mixed).toMatchObject({
+        components: [{ component: "api", state: "settled", releaseLabel: "v1.1.0" }, { component: "web", state: "settled", releaseLabel: "v1.0.0" }],
+        redeploy: [],
+        rollback: "chant components rollback prod --release v1.0.0",
+      });
+
+      // The same promote run again puts web on v1.1.0: one release, nothing mixed.
+      await deploy({ component: "web", timestamp: "2026-10-17T13:20:00.000Z", releaseDigest: v2.releaseDigest });
+      const settled = result(await workspaceStatus({ cwd: dir, env: "prod", now: NOW })).members[0].environments[0];
+      expect(settled).not.toHaveProperty("mixed");
+    });
+  });
+
+  test("a revoked release's rollback line names the release the environment ran before it", async () => {
+    await withTestDir(async (dir) => {
+      const { v2, deploy } = await setup(dir);
+      for (const component of ["api", "web"]) await deploy({ component, timestamp: "2026-10-17T13:00:00.000Z", releaseDigest: v2.releaseDigest });
+      writeFileSync(
+        join(dir, "chant.workspace.json"),
+        JSON.stringify({ name: "acme", schema: 1, members: [{ name: "root", dir: ".", kind: "other", because: "the fixture" }], ci: { green: { branch: "main", phases: { test: ["test"] }, require: ["test"] } } }, null, 2),
+      );
+      git(dir, "commit", "-q", "-am", "ci.green");
+      const record = { schema: 1, tag: "revoked", commit: v2.commit, branch: "main", at: "2026-10-17T13:30:00.000Z", phase: "test", run: { name: "test", id: 77, conclusion: "failure", url: null } };
+      git(dir, "tag", "-a", "-m", `ci: phase test failed\n\n${JSON.stringify(record, null, 2)}\n`, `ci/revoked/${v2.commit}`, v2.commit);
+
+      const prod = result(await workspaceStatus({ cwd: dir, env: "prod", now: NOW })).members[0].environments[0];
+      expect(prod.releases.map((r) => [r.component, r.revoked?.rollback])).toEqual([
+        ["api", "chant components rollback prod --release v1.0.0"],
+        ["web", "chant components rollback prod --release v1.0.0"],
+      ]);
+      expect(prod).not.toHaveProperty("mixed");
+    });
+  });
+});

package/src/workspace/status-revoked.test.ts

@@ -0,0 +1,153 @@
+/**
+ * #4033 (ws-105): a release cut from a revoked commit, read at read time from
+ * the `ci/revoked/<sha>` tag. `workspace status` flags an environment that
+ * runs it, with the rollback line, and reads its pending gate as superseded;
+ * `release list` marks it. Against temp repos; nothing is pushed.
+ */
+
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { withTestDir } from "@intentius/chant-test-utils";
+import { spawnSync } from "node:child_process";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Ajv2020 } from "ajv/dist/2020";
+import statusSchema from "./status.schema.json";
+import releasesSchema from "./releases.schema.json";
+import { formatStatus, workspaceStatus, type StatusDocument } from "./status";
+import { releasesDocument } from "./releases";
+import { contract } from "./__fixtures__/contract-repo";
+import { appendCut, makeRelease, persistRelease, type Release } from "../lifecycle/release-store";
+import { appendReleaseRecord } from "../lifecycle/release-ledger";
+import { appendPendingGate } from "../lifecycle/gate-ledger";
+import type { CommandContext } from "../cli/registry";
+import { contentDigest } from "../content-digest";
+
+const validateStatus = new Ajv2020({ strict: true, allErrors: true }).compile(statusSchema);
+const { expectValid: expectValidReleases } = contract(releasesSchema);
+
+function git(cwd: string, ...args: string[]): string {
+  const r = spawnSync("git", args, { cwd, encoding: "utf-8" });
+  if (r.status !== 0) throw new Error(`git ${args.join(" ")}: ${r.stderr}`);
+  return r.stdout.trim();
+}
+
+const DOC = `jcs1-sha256:${"d".repeat(64)}`;
+const NOW = "2026-10-16T14:00:00.000Z";
+
+/** A workspace whose root member runs release v1.0.0 in prod and waits at its staging gate, and a second release v1.1.0 from a later commit. */
+async function setup(dir: string): Promise<{ old: string; release: Release; next: Release }> {
+  git(dir, "init", "-q", "-b", "main");
+  git(dir, "config", "user.email", "t@chant.dev");
+  git(dir, "config", "user.name", "T");
+  writeFileSync(
+    join(dir, "chant.workspace.json"),
+    JSON.stringify({ name: "acme", schema: 1, members: [{ name: "root", dir: ".", kind: "other", because: "the fixture" }], ci: { green: { branch: "main", phases: { test: ["test"] }, require: ["test"] } } }, null, 2),
+  );
+  git(dir, "add", ".");
+  git(dir, "commit", "-q", "-m", "init");
+  const old = git(dir, "rev-parse", "HEAD");
+  git(dir, "commit", "-q", "--allow-empty", "-m", "next");
+  const later = git(dir, "rev-parse", "HEAD");
+  const at = (commit: string) =>
+    makeRelease({ member: null, commit, artifactDigests: [], targets: ["staging", "prod"].map((env) => ({ env, templates: [{ component: "api", path: "t.json", digest: `sha256:${"c".repeat(64)}` }], params: [] })) });
+  const release = at(old);
+  const next = at(later);
+  for (const [r, label, ts] of [[release, "v1.0.0", "10"], [next, "v1.1.0", "11"]] as const) {
+    await persistRelease(r, [], { cwd: dir });
+    await appendCut({ releaseDigest: r.releaseDigest, label, actor: "alice", timestamp: `2026-10-16T${ts}:00:00.000Z`, runOrigin: null }, { cwd: dir });
+  }
+  const deploy = { component: "api", digest: contentDigest("api image"), runId: "r", actor: "ci" };
+  await appendReleaseRecord({ ...deploy, env: "prod", gitSha: old, timestamp: "2026-10-16T12:00:00.000Z", releaseDigest: release.releaseDigest }, { cwd: dir });
+  await appendReleaseRecord({ ...deploy, env: "staging", gitSha: later, timestamp: "2026-10-16T12:00:00.000Z", releaseDigest: next.releaseDigest }, { cwd: dir });
+  for (const [r, env] of [[release, "staging"], [next, "prod"]] as const) {
+    await appendPendingGate(
+      { op: "release", gate: `${env}-release`, timestamp: "2026-10-16T13:00:00.000Z", expiresAt: "2999-01-01T00:00:00.000Z", planDigest: DOC, environment: env, releaseDigest: r.releaseDigest },
+      { cwd: dir },
+    );
+  }
+  return { old, release, next };
+}
+
+function revoke(dir: string, sha: string): void {
+  const record = { schema: 1, tag: "revoked", commit: sha, branch: "main", at: "2026-10-16T12:30:00.000Z", phase: "test", run: { name: "test", id: 77, conclusion: "failure", url: "https://example.test/runs/77" } };
+  git(dir, "tag", "-a", "-m", `ci: phase test failed in test (failure)\n\n${JSON.stringify(record, null, 2)}\n`, `ci/revoked/${sha}`, sha);
+}
+
+function result(doc: StatusDocument): Extract<StatusDocument, { members: unknown }> {
+  if ("error" in doc) throw new Error(`${doc.error.code}: ${doc.error.message}`);
+  expect(validateStatus(doc), JSON.stringify(validateStatus.errors, null, 2)).toBe(true);
+  return doc;
+}
+
+describe("a revoked release in workspace status and release list (#4033)", () => {
+  test("an environment running a release cut from a revoked commit is flagged with the rollback line, and the release's pending gate is superseded", async () => {
+    await withTestDir(async (dir) => {
+      const { old, release, next } = await setup(dir);
+
+      // Before the revocation nothing is flagged.
+      const before = result(await workspaceStatus({ cwd: dir, env: "prod", compareTo: "staging", now: NOW }));
+      expect(before.members[0].environments[0].releases[0]).not.toHaveProperty("revoked");
+      expect(before.members[0].gates.map((g) => [g.name, g.state])).toEqual([["prod-release", "pending"], ["staging-release", "pending"]]);
+
+      revoke(dir, old);
+      const doc = result(await workspaceStatus({ cwd: dir, env: "prod", compareTo: "staging", now: NOW }));
+      const [prod, staging] = doc.members[0].environments;
+      expect(prod.releases[0].revoked).toEqual({
+        commit: old,
+        tag: `ci/revoked/${old}`,
+        tagged: expect.any(String),
+        phase: "test",
+        run: { name: "test", id: 77, conclusion: "failure", url: "https://example.test/runs/77" },
+        signer: null,
+        releaseDigest: release.releaseDigest,
+        label: "v1.0.0",
+        rollback: "chant components rollback prod --component api",
+      });
+      // staging runs the later release, which is not revoked.
+      expect(staging.releases[0]).not.toHaveProperty("revoked");
+
+      const [prodGate, stagingGate] = doc.members[0].gates;
+      expect(prodGate).toMatchObject({ name: "prod-release", releaseDigest: next.releaseDigest, state: "pending" });
+      expect(prodGate).not.toHaveProperty("revoked");
+      expect(stagingGate).toMatchObject({ name: "staging-release", releaseDigest: release.releaseDigest, state: "superseded", revoked: { commit: old, tag: `ci/revoked/${old}`, phase: "test" } });
+
+      expect(formatStatus(doc)).toContain(
+        `  prod: api runs release v1.0.0, revoked by ci/revoked/${old} (phase test failed in test (run 77)); roll back: chant components rollback prod --component api`,
+      );
+    });
+  });
+
+  test("release list marks the revoked release, in JSON and in text", async () => {
+    await withTestDir(async (dir) => {
+      const { old } = await setup(dir);
+      revoke(dir, old);
+      const doc = await releasesDocument({ cwd: dir });
+      expectValidReleases(doc);
+      if ("error" in doc) throw new Error(doc.error.message);
+      expect(doc.releases.map((r) => [r.label, r.revoked?.tag ?? null])).toEqual([
+        ["v1.1.0", null],
+        ["v1.0.0", `ci/revoked/${old}`],
+      ]);
+
+      const out: string[] = [];
+      const err: string[] = [];
+      vi.spyOn(console, "log").mockImplementation((...m: unknown[]) => { out.push(m.join(" ")); });
+      vi.spyOn(console, "error").mockImplementation((...m: unknown[]) => { err.push(m.join(" ")); });
+      const cwd = process.cwd();
+      try {
+        process.chdir(dir);
+        const { runReleaseList } = await import("../cli/handlers/release");
+        expect(await runReleaseList({ args: {} } as unknown as CommandContext)).toBe(0);
+      } finally {
+        process.chdir(cwd);
+      }
+      expect(out.find((l) => l.startsWith("v1.0.0"))).toMatch(/ {2}revoked$/);
+      expect(out.find((l) => l.startsWith("v1.1.0"))).not.toMatch(/revoked/);
+      expect(err).toContain(`  v1.0.0: revoked by ci/revoked/${old}, phase test failed in test (run 77)`);
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+});

package/src/workspace/status-stewards.ts

@@ -78,6 +78,10 @@ export interface StatusStewardRun {
   status: OpRunRecord["status"];
   started: string;
   ended: string;
+  /** The commit the run built from (#4020). Absent on a record written before chant 0.124.28. */
+  gitSha?: string;
+  /** The CI run the Op ran in (#4020), when it ran in CI: the shape a release's `runOrigin` has. */
+  runOrigin?: OpRunRecord["runOrigin"];
   /**
    * The gate the run stopped at, for a `gated` run: its name, when the run
    * stopped there, the op it is recorded under (the Op's own, or the
@@ -411,6 +415,8 @@ export async function readMemberStewards(
             status: newest.status,
             started: newest.started,
             ended: newest.ended,
+            ...(newest.gitSha ? { gitSha: newest.gitSha } : {}),
+            ...(newest.runOrigin ? { runOrigin: newest.runOrigin } : {}),
             gate: newest.gate ? gateOf(newest.gate, op.name) : null,
             point: point?.wait ?? null,
             phases: newest.phases.map((p) => ({