@intentius/chant 0.124.28 → 0.124.30

package/src/cli/handlers/lifecycle-gc.test.ts

@@ -0,0 +1,126 @@
+/** #4036: `chant lifecycle gc [--yes] [--push] [--json]`, in temp repos. */
+
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import type { ParsedArgs } from "../registry";
+import { runLifecycleGc } from "./lifecycle-gc";
+import { writeLedgerFiles } from "../../lifecycle/git";
+import { makeRelease } from "../../lifecycle/release-store";
+import type { GcReport } from "../../lifecycle/retention";
+
+function args(o: Partial<ParsedArgs>): ParsedArgs {
+  return { command: "lifecycle", path: ".", format: "", fix: false, watch: false, verbose: false, help: false, live: false, ...o };
+}
+
+const git = (cwd: string, ...a: string[]) => execFileSync("git", a, { cwd, encoding: "utf-8" }).trim();
+
+let dir: string;
+let cwd: string;
+let out: string[];
+let err: string[];
+beforeEach(() => {
+  cwd = process.cwd();
+  dir = realpathSync(mkdtempSync(join(tmpdir(), "lifecycle-gc-")));
+  vi.stubEnv("CHANT_RUN_EVENTS_DIR", join(dir, ".events"));
+  git(dir, "init", "-q", "-b", "main");
+  git(dir, "config", "user.email", "t@t");
+  git(dir, "config", "user.name", "t");
+  process.chdir(dir);
+  out = [];
+  err = [];
+  vi.spyOn(console, "log").mockImplementation((s: string) => void out.push(String(s)));
+  vi.spyOn(console, "error").mockImplementation((s: string) => void err.push(String(s)));
+});
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllEnvs();
+  process.chdir(cwd);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function commitAll(): string {
+  writeFileSync(join(dir, "README.md"), "x\n");
+  git(dir, "add", ".");
+  git(dir, "commit", "-q", "-m", "init");
+  return git(dir, "rev-parse", "HEAD");
+}
+
+const changeSet = `_change-sets/jcs1-sha256_${"1".repeat(64)}.json`;
+const ctx = (o: Partial<ParsedArgs>) => ({ args: args(o), plugins: [], serializers: [] });
+const report = (): GcReport => JSON.parse(out.join("\n")) as GcReport;
+
+describe("chant lifecycle gc", () => {
+  test("a dry run by default; --yes prunes in one local commit and pushes nothing", async () => {
+    writeFileSync(join(dir, "chant.workspace.json"), JSON.stringify({ name: "w", schema: 1, members: [], retention: { changeSets: { days: 0 } } }));
+    commitAll();
+    await writeLedgerFiles([{ path: changeSet, content: "{}\n", expectPriorSha: null }], "fixture", { cwd: dir });
+    const tip = git(dir, "rev-parse", "chant/lifecycle");
+
+    expect(await runLifecycleGc(ctx({}))).toBe(0);
+    expect(out[0]).toMatch(/^chant\/lifecycle at [0-9a-f]{12}: would remove 1 change set\(s\), 0 release\(s\) and 0 template\(s\)/);
+    expect(err.join("\n")).toContain("Dry run: nothing was removed");
+    expect(git(dir, "rev-parse", "chant/lifecycle")).toBe(tip);
+
+    out = [];
+    expect(await runLifecycleGc(ctx({ yes: true, json: true }))).toBe(0);
+    const r = report();
+    expect(r.dryRun).toBe(false);
+    expect(r.policy.changeSets.days).toBe(0);
+    expect(r.lifecycle.remove.map((f) => f.path)).toEqual([changeSet]);
+    expect(r.lifecycle.commit).toBe(git(dir, "rev-parse", "chant/lifecycle"));
+    expect(git(dir, "rev-parse", "chant/lifecycle^")).toBe(tip);
+    expect(r.lifecycle.pushed).toBe(false);
+  });
+
+  test("outside a workspace the defaults apply, and a release of a revoked commit is not promotable", async () => {
+    const head = commitAll();
+    const cut = (commit: string) => {
+      const r = makeRelease({ member: null, commit, artifactDigests: [], targets: [{ env: "prod", templates: [], params: [] }] });
+      return { r, line: JSON.stringify({ version: 1, releaseDigest: r.releaseDigest, label: null, actor: "a", timestamp: new Date().toISOString(), runOrigin: null, signature: null }) };
+    };
+    const revoked = cut(head);
+    const fine = cut("b".repeat(40));
+    const file = (d: string) => `_releases/${d.replace(/:/g, "_")}.json`;
+    await writeLedgerFiles(
+      [
+        { path: changeSet, content: "{}\n" },
+        { path: file(revoked.r.releaseDigest), content: `${JSON.stringify(revoked.r)}\n` },
+        { path: file(fine.r.releaseDigest), content: `${JSON.stringify(fine.r)}\n` },
+        { path: "_releases/cuts.jsonl", content: `${revoked.line}\n${fine.line}\n` },
+      ],
+      "fixture",
+      { cwd: dir },
+    );
+    git(dir, "tag", `ci/revoked/${head}`, head);
+
+    expect(await runLifecycleGc(ctx({ json: true }))).toBe(0);
+    const r = report();
+    expect(r.policy.releases).toEqual({ days: 14, keep: 10 });
+    expect(r.lifecycle.remove.map((f) => f.path)).toEqual([file(revoked.r.releaseDigest)]);
+    expect(r.lifecycle.keep.map((f) => [f.path, f.reasons.map((x) => x.code)])).toEqual(
+      expect.arrayContaining([[changeSet, ["within-window"]], [file(fine.r.releaseDigest), ["newest", "within-window"]]]),
+    );
+  });
+
+  test("a workspace whose declaration can't be read prunes nothing", async () => {
+    writeFileSync(join(dir, "chant.workspace.json"), JSON.stringify({ name: "w", schema: 1, members: [], retention: { changeSets: { days: -1 } } }));
+    commitAll();
+    expect(await runLifecycleGc(ctx({ yes: true }))).toBe(1);
+    expect(err.join("\n")).toContain("its retention policy is unknown and nothing is pruned");
+  });
+
+  test("a directory outside git is refused", async () => {
+    const plain = realpathSync(mkdtempSync(join(tmpdir(), "lifecycle-gc-plain-")));
+    try {
+      process.chdir(plain);
+      expect(await runLifecycleGc(ctx({}))).toBe(1);
+      expect(err.join("\n")).toContain("not in a git repository");
+    } finally {
+      process.chdir(dir);
+      rmSync(plain, { recursive: true, force: true });
+    }
+  });
+});

package/src/cli/handlers/lifecycle-gc.ts

@@ -0,0 +1,146 @@
+/**
+ * `chant lifecycle gc [--yes] [--push] [--json] [--verbose]` (#4036): prune
+ * stored change sets, releases and their templates from `chant/lifecycle`, and
+ * run event files from this host, by the retention policy.
+ *
+ * Without `--yes` it is a dry run: it prints what it would remove and changes
+ * nothing. With `--yes` it writes one commit to the local `chant/lifecycle`
+ * that removes those files, and deletes the run event files. It pushes only
+ * with `--push`. History is never rewritten, so a pruned file stays in the
+ * branch's earlier commits. The rules are in ../../lifecycle/retention.ts.
+ *
+ * The policy is the defaults, overridden by the `retention` block of the
+ * workspace declaration at base when the checkout is a workspace. The prune
+ * covers the whole branch, every member, from wherever in the repository it
+ * runs.
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { formatError, formatSuccess, formatWarning } from "../format";
+import type { CommandContext } from "../registry";
+import type { RetentionPolicy } from "../../lifecycle/retention-policy";
+
+const USAGE = "chant lifecycle gc [--yes] [--push] [--json] [--verbose]";
+
+function tryGit(cwd: string, args: string[]): string | null {
+  try {
+    return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/** Whether a workspace declaration sits in `cwd` or a directory above it, up to the repository's top. */
+function inWorkspace(cwd: string, top: string): boolean {
+  for (let dir = cwd; ; dir = dirname(dir)) {
+    if (existsSync(join(dir, "chant.workspace.json")) || existsSync(join(dir, "chant.workspace.jsonc"))) return true;
+    if (dir === top || dirname(dir) === dir) return false;
+  }
+}
+
+/** Every commit with a `ci/revoked/<sha>` tag, counted as `chant release cut` counts it. */
+async function revokedCommits(cwd: string, top: string, green: import("../../workspace/declaration").CiGreen | null, workspace: boolean): Promise<Set<string>> {
+  if (workspace) {
+    const { readCiTags } = await import("../../workspace/ci-green");
+    const base = green
+      ? (tryGit(top, ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${green.branch}^{commit}`]) ??
+        tryGit(top, ["rev-parse", "--verify", "--quiet", `refs/heads/${green.branch}^{commit}`]) ??
+        tryGit(top, ["rev-parse", "HEAD"]))
+      : null;
+    return new Set(readCiTags(top, green, base).revoked.keys());
+  }
+  // With no declaration every tag counts, as readCiTags counts them without `ci.green`.
+  const out = tryGit(cwd, ["for-each-ref", "--format=%(refname:lstrip=4)", "refs/tags/ci/revoked/"]) ?? "";
+  return new Set(out.split("\n").filter((s) => /^[0-9a-f]{40,64}$/.test(s)));
+}
+
+const kb = (bytes: number): string => (bytes >= 1024 * 1024 ? `${(bytes / 1024 / 1024).toFixed(1)} MB` : `${(bytes / 1024).toFixed(1)} KB`);
+
+export async function runLifecycleGc(ctx: CommandContext): Promise<number> {
+  const { args } = ctx;
+  if (args.extraPositional) {
+    console.error(formatError({ message: `lifecycle gc takes no argument, and was given "${args.extraPositional}"`, hint: USAGE }));
+    return 1;
+  }
+  const cwd = resolve(".");
+  const top = tryGit(cwd, ["rev-parse", "--show-toplevel"]);
+  if (!top) {
+    console.error(formatError({ message: "lifecycle gc prunes the chant/lifecycle branch, and this directory is not in a git repository", hint: USAGE }));
+    return 1;
+  }
+  const dryRun = args.yes !== true;
+
+  const { resolveRetention } = await import("../../lifecycle/retention-policy");
+  let policy: RetentionPolicy = resolveRetention(null);
+  let green: import("../../workspace/declaration").CiGreen | null = null;
+  const workspace = inWorkspace(cwd, top);
+  if (workspace) {
+    const { scopeSource } = await import("../../workspace/write-scope");
+    const source = scopeSource(cwd);
+    if (!source.declaration) {
+      console.error(formatError({ message: `the workspace declaration can't be read, so its retention policy is unknown and nothing is pruned: ${source.failure?.message ?? "no declaration"}` }));
+      return 1;
+    }
+    policy = resolveRetention(source.declaration.retention);
+    green = source.declaration.ci?.green ?? null;
+  }
+
+  // Read the remote's facts first: a prune planned on a stale branch could
+  // remove what a newer gate binds, and a forked branch must not be pushed over.
+  const { fetchLifecycleStatus } = await import("../../lifecycle/git");
+  const fetched = await fetchLifecycleStatus({ cwd });
+  if (fetched.status === "diverged" || fetched.status === "unreachable") {
+    const why = fetched.status === "diverged" ? `the local chant/lifecycle and ${fetched.remote}'s have forked` : `${fetched.remote} did not answer: ${fetched.stderr}`;
+    if (!dryRun) {
+      console.error(formatError({ message: `nothing was pruned: ${why}`, hint: "Bring chant/lifecycle up to date with its remote, then run again." }));
+      return 1;
+    }
+    if (!args.json) console.error(formatWarning({ message: `planned on the local branch only: ${why}` }));
+  }
+
+  const { runLifecycleGc: run } = await import("../../lifecycle/retention");
+  const report = await run({
+    cwd,
+    policy,
+    now: new Date(),
+    revokedCommits: await revokedCommits(cwd, top, green, workspace),
+    dryRun,
+    push: args.push === true,
+  });
+
+  if (args.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return 0;
+  }
+
+  const lc = report.lifecycle;
+  const count = (list: ReadonlyArray<{ kind: string }>, kind: string) => list.filter((f) => f.kind === kind).length;
+  const bytes = lc.remove.reduce((n, f) => n + f.bytes, 0);
+  const verb = dryRun ? "would remove" : "removed";
+  if (!lc.tip) {
+    console.error("No chant/lifecycle branch: nothing stored to prune.");
+  } else {
+    console.log(
+      `chant/lifecycle at ${lc.tip.slice(0, 12)}: ${verb} ${count(lc.remove, "change-set")} change set(s), ${count(lc.remove, "release")} release(s) and ${count(lc.remove, "template")} template(s), ${kb(bytes)}; ` +
+        `keeps ${count(lc.keep, "change-set")}, ${count(lc.keep, "release")} and ${count(lc.keep, "template")}`,
+    );
+    console.log(`  tree at the tip: ${lc.before.files} file(s), ${kb(lc.before.bytes)} before; ${lc.after.files} file(s), ${kb(lc.after.bytes)} after. The ledgers (${kb(lc.before.ledgers.bytes)}) are never pruned, and history keeps every removed file.`);
+    if (args.verbose) for (const f of lc.remove) console.log(`  - ${f.path}`);
+  }
+  const ev = report.runEvents;
+  if (ev.dir) {
+    console.log(`  run events in ${ev.dir}: ${verb} ${ev.remove.length} file(s), ${kb(ev.remove.reduce((n, f) => n + f.bytes, 0))}; keeps ${ev.kept.files}`);
+    if (args.verbose) for (const f of ev.remove) console.log(`  - ${f.file}`);
+  }
+  if (dryRun) {
+    console.error("Dry run: nothing was removed. Run again with --yes to prune.");
+  } else if (lc.commit) {
+    console.error(formatSuccess(`Pruned in commit ${lc.commit.slice(0, 12)} on chant/lifecycle`));
+    if (lc.pushed) console.error("  pushed");
+    else if (lc.pushWarning) console.error(formatWarning({ message: lc.pushWarning }));
+    else console.error("  not pushed: run with --push, or push chant/lifecycle yourself");
+  }
+  return 0;
+}

package/src/cli/handlers/pr.test.ts

@@ -8,6 +8,7 @@
 
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
+import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import type { DriverComponent } from "../../components/driver";
@@ -58,6 +59,8 @@ vi.mock("../../op/gate", async () => {
 });
 
 const failing = new Set<string>();
+/** Called as a component's apply starts, before it can fail. */
+let onRun: (root: string) => void = () => {};
 vi.mock("../../components/fan-out-support", async () => {
   const { CapabilityRegistry } = await import("../../components/capability");
   const { planFanOut } = await import("../../components/fan-out");
@@ -78,6 +81,7 @@ vi.mock("../../components/fan-out-support", async () => {
       return {};
     },
     async run(_ctx: DeployContext, input: { root: string }) {
+      onRun(input.root);
       if (failing.has(input.root)) throw new Error(`${input.root} failed`);
       return { outputs: {} };
     },
@@ -106,6 +110,7 @@ const { checkRunEventLines, stepTrail } = await import("../../workspace/__fixtur
 
 let dir: string;
 let out: string[];
+let errors: string[];
 
 const ctx = (a: Partial<ParsedArgs>) =>
   ({ args: { command: "components", path: "pr-apply", format: "", fix: false, watch: false, verbose: false, help: false, live: false, base: "main", env: "prod", output: dir, eventsJson: true, ...a } as ParsedArgs, plugins: [] }) as never;
@@ -113,10 +118,12 @@ const ctx = (a: Partial<ParsedArgs>) =>
 beforeEach(async () => {
   dir = await mkdtemp(join(tmpdir(), "pr-events-"));
   out = [];
+  errors = [];
   failing.clear();
+  onRun = () => {};
   gateLedger = memoryGateLedgerPort();
   vi.spyOn(process.stdout, "write").mockImplementation((chunk: string | Uint8Array) => { out.push(String(chunk)); return true; });
-  vi.spyOn(console, "error").mockImplementation(() => {});
+  vi.spyOn(console, "error").mockImplementation((...m: unknown[]) => { errors.push(m.map(String).join(" ")); });
   vi.spyOn(console, "log").mockImplementation(() => {});
 });
 
@@ -182,6 +189,146 @@ describe("pr-apply --events-json", () => {
   });
 });
 
+/** Plan pull request 12 and approve its digest, as a reviewer would. */
+async function planAndApprove(): Promise<void> {
+  await runComponentsPrPlan(ctx({ pr: 12 }));
+  const digest = await plannedDigest();
+  gateLedger = memoryGateLedgerPort({
+    resolutions: [{ version: 1, kind: "resolution", op: "pr-12", gate: "pr-apply", resolvedBy: "github:alice", timestamp: new Date().toISOString(), planDigest: digest }],
+  });
+  out = [];
+  errors = [];
+}
+
+/** The job log's wave and component lines, without colour. */
+const logLines = (): string[] =>
+  errors.map((l) => l.replace(/\u001b\[[0-9;]*m/g, "")).filter((l) => /^wave \d|^ {2}\S+: /.test(l));
+
+describe("pr-apply's job log (#4007)", () => {
+  test("without --events-json, a line as each wave starts and as each component settles, in order", async () => {
+    await planAndApprove();
+    expect(await runComponentsPrApply(ctx({ pr: 12, eventsJson: false }))).toBe(0);
+    expect(out).toEqual([]);
+    expect(logLines()).toEqual(["wave 1/2: net", "  net: applied", "wave 2/2: app", "  app: applied"]);
+  });
+
+  test("a failed dependency: the component behind it settles blocked, naming it, in the log and the stream", async () => {
+    await planAndApprove();
+    failing.add("net");
+    expect(await runComponentsPrApply(ctx({ pr: 12 }))).toBe(1);
+    expect(logLines()).toEqual(["wave 1/2: net", "  net: failed", "  app: blocked by net, not run"]);
+    const events = checkRunEventLines(out);
+    const blocked = events.find((e) => e.type === "component-settle" && e.component === "app");
+    expect(blocked).toMatchObject({ type: "component-settle", wave: 2, component: "app", status: "blocked", blockedBy: "net" });
+    expect(events.some((e) => e.type === "component-start" && e.component === "app")).toBe(false);
+    expect(events.some((e) => e.type === "wave-start" && e.wave === 2)).toBe(false);
+    expect(events.at(-1)).toMatchObject({ type: "run-settle", status: "failed" });
+  });
+
+  test("a resumed apply settles what the earlier attempt applied as already-applied, before the gate", async () => {
+    await planAndApprove();
+    const resume = join(dir, "attempt.json");
+    failing.add("app");
+    expect(await runComponentsPrApply(ctx({ pr: 12, resume, eventsJson: false }))).toBe(1);
+    failing.clear();
+    out = [];
+    errors = [];
+    expect(await runComponentsPrApply(ctx({ pr: 12, resume }))).toBe(0);
+    const events = checkRunEventLines(out);
+    const settles = events.filter((e) => e.type === "component-settle").map((e) => [e.component, (e as { status: string }).status, (e as { wave: number }).wave]);
+    expect(settles).toEqual([["net", "already-applied", 1], ["app", "ok", 1]]);
+    const gate = events.findIndex((e) => e.type === "phase-start" && e.phase === "gate");
+    expect(events.findIndex((e) => e.type === "component-settle" && e.component === "net")).toBeLessThan(gate);
+    expect(logLines()).toEqual(["  net: already applied in an earlier attempt", "wave 1/1: app", "  app: applied"]);
+  });
+});
+
+describe("--resume carries only an unchanged input (#4081)", () => {
+  test("a component whose input moved since the attempt runs again, and says why", async () => {
+    await planAndApprove();
+    const resume = join(dir, "attempt.json");
+    failing.add("app");
+    expect(await runComponentsPrApply(ctx({ pr: 12, resume, eventsJson: false }))).toBe(1);
+    expect(JSON.parse(readFileSync(resume, "utf8")).inputs).toEqual({ net: expect.stringMatching(/^jcs1-sha256:/) });
+    failing.clear();
+    errors = [];
+    const step = ESTATE[0]!.deploy[0]!.steps[0] as Record<string, unknown>;
+    step.note = "a different change of the same shape";
+    const ran: string[] = [];
+    onRun = (name) => ran.push(name);
+    try {
+      expect(await runComponentsPrApply(ctx({ pr: 12, resume, eventsJson: false }))).toBe(0);
+    } finally {
+      delete step.note;
+    }
+    expect(ran).toEqual(["net", "app"]);
+    expect(errors.join("\n")).toContain("net: changed since the earlier attempt, so it runs again");
+  });
+
+  test("a record without input digests does not carry", async () => {
+    await planAndApprove();
+    const resume = join(dir, "attempt.json");
+    failing.add("app");
+    expect(await runComponentsPrApply(ctx({ pr: 12, resume, eventsJson: false }))).toBe(1);
+    const { writeFileSync } = await import("node:fs");
+    const record = JSON.parse(readFileSync(resume, "utf8"));
+    delete record.inputs;
+    writeFileSync(resume, JSON.stringify(record));
+    failing.clear();
+    errors = [];
+    const ran: string[] = [];
+    onRun = (name) => ran.push(name);
+    expect(await runComponentsPrApply(ctx({ pr: 12, resume, eventsJson: false }))).toBe(0);
+    expect(ran).toEqual(["net", "app"]);
+    expect(errors.join("\n")).toMatch(/does not carry: it does not record what each component applied/);
+  });
+});
+
+describe("--report-url (#4007)", () => {
+  test("refuses a URL it can't upload to, before anything plans", async () => {
+    expect(await runComponentsPrPlan(ctx({ pr: 12, reportUrl: "https://example.invalid/reports" }))).toBe(1);
+    expect(errors.join("\n")).toMatch(/takes an s3:\/\/<bucket>\/<prefix> or file:\/\/<directory> URL/);
+    expect(out).toEqual([]);
+  });
+
+  test("file://: the report, the change set and the events land under <pr>/<commit>/, the events as each wave settles", async () => {
+    const { pathToFileURL } = await import("node:url");
+    const { readFile } = await import("node:fs/promises");
+    const reports = join(dir, "reports");
+    const reportUrl = pathToFileURL(reports).href;
+    await runComponentsPrPlan(ctx({ pr: 12, reportUrl }));
+    const at = join(reports, "12", HEAD);
+    expect(JSON.parse(await readFile(join(at, "pr-plan.json"), "utf8"))).toMatchObject({ stage: "plan", pr: 12, status: "planned" });
+    expect(checkRunEventLines((await readFile(join(at, "pr-plan.events.jsonl"), "utf8")).split(/(?<=\n)/))[0]).toMatchObject({ type: "run-start" });
+
+    await planAndApprove();
+    // What a reader of the URL sees while wave 2 applies: wave 1 settled.
+    let seenMidRun: string[] = [];
+    onRun = (root) => {
+      if (root === "app") seenMidRun = readFileSync(join(at, "pr-apply.events.jsonl"), "utf8").split(/(?<=\n)/);
+    };
+    expect(await runComponentsPrApply(ctx({ pr: 12, reportUrl }))).toBe(0);
+    const mid = seenMidRun.map((l) => JSON.parse(l) as { type: string; wave?: number; status?: string });
+    expect(mid.some((e) => e.type === "wave-settle" && e.wave === 1 && e.status === "ok")).toBe(true);
+    expect(mid.some((e) => e.type === "run-settle")).toBe(false);
+
+    const final = checkRunEventLines((await readFile(join(at, "pr-apply.events.jsonl"), "utf8")).split(/(?<=\n)/));
+    expect(final.at(-1)).toMatchObject({ type: "run-settle", status: "ok" });
+    expect(final.map((e) => e.type).join("\n")).toBe(out.map((l) => JSON.parse(l).type).join("\n"));
+    expect(JSON.parse(await readFile(join(at, "pr-apply.json"), "utf8"))).toMatchObject({ stage: "apply", status: "applied" });
+    expect(JSON.parse(await readFile(join(at, "change-set.json"), "utf8"))).toHaveProperty("digest");
+    expect(errors.join("\n")).toContain(`report  : ${reportUrl}/12/${HEAD}/`);
+  });
+
+  test("without --events-json, only the report and the change set are copied", async () => {
+    const { pathToFileURL } = await import("node:url");
+    const { readdir } = await import("node:fs/promises");
+    const reports = join(dir, "reports");
+    await runComponentsPrPlan(ctx({ pr: 12, reportUrl: pathToFileURL(reports).href, eventsJson: false }));
+    expect((await readdir(join(reports, "12", HEAD))).sort()).toEqual(["change-set.json", "pr-plan.json"]);
+  });
+});
+
 describe("--events-json beside --json", () => {
   test("is refused on pr-plan and pr-apply before anything plans, since both print to stdout", async () => {
     const errors: string[] = [];