@intentius/chant 0.124.34 → 0.124.36

package/src/workspace/ci-serve-land.test.ts

@@ -0,0 +1,176 @@
+/**
+ * #4168 4.4 — `ci serve --land` fast-forwards the target to a pushed
+ * `chant/land/<name>` branch once its pre-merge phases pass on it, and
+ * #4016 gap 6 — `ci serve --forge git` reads a plain git server's refs.
+ *
+ * Each test works in its own clone with a bare origin. The build and the
+ * judge are fakes; `ci-serve-land.e2e.test.ts` runs the real ones.
+ */
+
+import { join } from "node:path";
+import { afterAll, describe, expect, test } from "vitest";
+import { cleanScratch, git, scratchDir, writeFiles } from "./__fixtures__/contract-repo";
+import { ciServeLands, formatCiServeEvent, gitCiServeForge, newCiServeRuntime, readCiServeState, type CiServeEvent, type CiServeOptions } from "./ci-serve";
+import type { CommitVerdict } from "./ci-green";
+
+afterAll(cleanScratch);
+
+function commit(root: string, file: string): string {
+  writeFiles(root, { [file]: `${file}\n` });
+  git(root, "add", "-A");
+  git(root, "commit", "-q", "-m", file);
+  return git(root, "rev-parse", "HEAD");
+}
+
+/** A clone on main with a bare origin. */
+function clone(): { root: string; origin: string; main: string } {
+  const origin = scratchDir("chant-serve-land-origin-");
+  git(origin, "init", "-q", "--bare");
+  const root = scratchDir("chant-serve-land-");
+  git(root, "init", "-q");
+  git(root, "symbolic-ref", "HEAD", "refs/heads/main");
+  git(root, "config", "user.name", "t");
+  git(root, "config", "user.email", "t@example.com");
+  git(root, "remote", "add", "origin", origin);
+  const main = commit(root, "a.txt");
+  git(root, "push", "-q", "origin", "main");
+  return { root, origin, main };
+}
+
+/** A commit on top of `from`, pushed as `chant/land/<name>`. */
+function pushLand(root: string, name: string, from: string, file: string): string {
+  git(root, "checkout", "-q", "--detach", from);
+  const sha = commit(root, file);
+  git(root, "push", "-q", "--force", "origin", `${sha}:refs/heads/chant/land/${name}`);
+  git(root, "checkout", "-q", "main");
+  return sha;
+}
+
+const verdict = (phases: Record<string, "pass" | "fail" | "pending">): CommitVerdict => {
+  const list = Object.entries(phases).map(([phase, v]) => ({ phase, verdict: v, runs: [], unmatched: [] }));
+  return { verdict: list.some((p) => p.verdict === "fail") ? "fail" : list.some((p) => p.verdict === "pending") ? "pending" : "pass", phases: list, failure: null };
+};
+
+function options(root: string, log: CiServeEvent[], extra: Partial<CiServeOptions> = {}): CiServeOptions & { built: { commit: string; phases: string[]; reason: string }[] } {
+  const built: { commit: string; phases: string[]; reason: string }[] = [];
+  return {
+    cwd: root,
+    forge: "git",
+    repo: "origin",
+    env: "prod",
+    client: gitCiServeForge(root),
+    stateDir: join(root, ".git", "serve"),
+    buildCommand: "true",
+    build: async ({ request }) => (built.push({ ...request }), 0),
+    land: { phases: ["check"] },
+    judgeLand: async () => verdict({ check: "pass" }),
+    log: (e) => log.push(e),
+    built,
+    ...extra,
+  };
+}
+
+const remoteHead = (origin: string, ref: string): string | undefined => {
+  try {
+    return git(origin, "rev-parse", "--verify", "--quiet", ref);
+  } catch {
+    return undefined;
+  }
+};
+
+describe("the git forge kind (#4016 gap 6)", () => {
+  test("reads the branch head through ls-remote, lists no pull requests, and says when the branch is missing", async () => {
+    const { root, main } = clone();
+    const forge = gitCiServeForge(root);
+    expect(await forge.branchHead("main")).toBe(main);
+    expect(await forge.branchHead("nope")).toBeUndefined();
+    expect(await forge.openPullRequests("main")).toEqual([]);
+    expect(forge.pullRequestFor).toBeUndefined();
+  });
+});
+
+describe("ci serve --land (#4168 4.4)", () => {
+  test("a land whose pre-merge phases pass moves the target to it and deletes the land branch, once", async () => {
+    const { root, origin, main } = clone();
+    const head = pushLand(root, "fix", main, "b.txt");
+    const log: CiServeEvent[] = [];
+    const opts = options(root, log);
+    const rt = newCiServeRuntime();
+    const pass = await ciServeLands(opts, rt);
+    await Promise.all(pass.started);
+
+    expect(opts.built).toEqual([{ commit: head, phases: ["check"], reason: "land" }]);
+    expect(remoteHead(origin, "refs/heads/main")).toBe(head);
+    expect(remoteHead(origin, "refs/heads/chant/land/fix")).toBeUndefined();
+    const state = readCiServeState(join(root, ".git", "serve", "chant-apply-prod.json"), { forge: "git", repo: "origin", env: "prod", branch: "main" });
+    expect(state.lands?.[`land:fix:${head}`]).toMatchObject({ branch: "chant/land/fix", commit: head, status: "landed" });
+    expect(log.map(formatCiServeEvent)).toContain(`chant/land/fix at ${head.slice(0, 12)} landed, and the land branch was deleted`);
+
+    // Nothing is left to serve.
+    expect((await ciServeLands(opts, rt)).started).toEqual([]);
+  });
+
+  test("a red pre-merge phase refuses the land and leaves the target and the land branch", async () => {
+    const { root, origin, main } = clone();
+    const head = pushLand(root, "red", main, "b.txt");
+    const log: CiServeEvent[] = [];
+    const opts = options(root, log, { judgeLand: async () => verdict({ check: "fail" }) });
+    await Promise.all((await ciServeLands(opts, newCiServeRuntime())).started);
+
+    expect(remoteHead(origin, "refs/heads/main")).toBe(main);
+    expect(remoteHead(origin, "refs/heads/chant/land/red")).toBe(head);
+    expect(log.map(formatCiServeEvent)).toContain(`chant/land/red at ${head.slice(0, 12)} was refused and left on the remote: the pre-merge phase check failed`);
+  });
+
+  test("a phase with no finished run, or a build that fails, refuses the land", async () => {
+    const { root, origin, main } = clone();
+    const a = pushLand(root, "norun", main, "b.txt");
+    const b = pushLand(root, "broken", main, "c.txt");
+    const log: CiServeEvent[] = [];
+    const opts = options(root, log, {
+      maxJobs: 2,
+      judgeLand: async () => verdict({ check: "pending" }),
+      build: async ({ request }) => (request.commit === b ? 3 : 0),
+    });
+    await Promise.all((await ciServeLands(opts, newCiServeRuntime())).started);
+
+    expect(remoteHead(origin, "refs/heads/main")).toBe(main);
+    const lines = log.map(formatCiServeEvent);
+    expect(lines).toContain(`chant/land/norun at ${a.slice(0, 12)} was refused and left on the remote: the build recorded no finished run for check`);
+    expect(lines).toContain(`chant/land/broken at ${b.slice(0, 12)} was refused and left on the remote: the build of check exited 3`);
+  });
+
+  test("a land that does not descend from the target is refused without a build, and a new push to it is tried again", async () => {
+    const { root, origin, main } = clone();
+    const stale = pushLand(root, "old", main, "b.txt");
+    const moved = commit(root, "c.txt");
+    git(root, "push", "-q", "origin", "main");
+    const log: CiServeEvent[] = [];
+    const opts = options(root, log);
+    const rt = newCiServeRuntime();
+    await Promise.all((await ciServeLands(opts, rt)).started);
+
+    expect(opts.built).toEqual([]);
+    expect(remoteHead(origin, "refs/heads/main")).toBe(moved);
+    expect(log.map(formatCiServeEvent)).toContain(
+      `chant/land/old at ${stale.slice(0, 12)} was refused and left on the remote: ${stale.slice(0, 12)} does not descend from main at ${moved.slice(0, 12)}; rebase chant/land/old onto it and push again`,
+    );
+    // The same head is not tried twice.
+    expect((await ciServeLands(opts, rt)).started).toEqual([]);
+
+    // Rebased and pushed again, it lands.
+    const rebased = pushLand(root, "old", moved, "b.txt");
+    await Promise.all((await ciServeLands(opts, rt)).started);
+    expect(remoteHead(origin, "refs/heads/main")).toBe(rebased);
+  });
+
+  test("lands wait for capacity", async () => {
+    const { root, main } = clone();
+    const head = pushLand(root, "fix", main, "b.txt");
+    const log: CiServeEvent[] = [];
+    const rt = newCiServeRuntime();
+    rt.inflight.set("busy", new Promise(() => {}));
+    expect((await ciServeLands(options(root, log), rt)).started).toEqual([]);
+    expect(log.map(formatCiServeEvent)).toContain(`chant/land/fix at ${head.slice(0, 12)} waits: --max-jobs jobs run`);
+  });
+});

package/src/workspace/ci-serve.test.ts

@@ -143,8 +143,8 @@ function serve(app: string, client: CiServeForge, extra: Partial<CiServeOptions>
       client,
       stateDir: state,
       holder: "serve-test",
-      // Most tests here cover the apply on merge, which #4168 made opt-in; the record tests pass false.
-      applyOnMerge: true,
+      // #4168: a merge gets the record job; the apply-on-merge tests pass true and tag a commit green.
+      applyOnMerge: false,
       // A job image of its own, so no setup line downloads OpenTofu.
       job: { image: "chant-ci-serve-test:local", chant: fakeChant(), hostEnv: env, passEnv: Object.keys(hostEnv ?? {}) },
       log: (e) => events.push(e),
@@ -155,6 +155,23 @@ function serve(app: string, client: CiServeForge, extra: Partial<CiServeOptions>
 
 const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 
+/** A workspace that declares `ci.green`, so a `ci/green/<sha>` tag counts (#4168 step 9), with that commit pushed as main. */
+function greenWorkspace(): ReturnType<typeof workspace> {
+  const w = workspace();
+  writeFiles(w.root, {
+    "chant.workspace.json": declaration([{ name: "app", dir: "app", kind: "other", because: "the app" }], { ci: { green: { branch: "main", phases: { test: ["test"] }, require: ["test"], source: "runs" } } }),
+  });
+  const main = commit(w.root, "app/green.txt", "declare ci.green");
+  git(w.root, "push", "-q", "origin", "main");
+  return { ...w, main };
+}
+
+/** Tag `sha` green on the forge, as the tick does. */
+function tagGreen(root: string, sha: string): void {
+  git(root, "tag", "-f", `ci/green/${sha}`, sha);
+  git(root, "push", "-q", "-f", "origin", `refs/tags/ci/green/${sha}`);
+}
+
 /** A commit on no branch, with `parent` when given, as a ledger commit stands in. */
 const ledgerCommit = (root: string, message: string, parent?: string): string => git(root, "commit-tree", EMPTY_TREE, ...(parent ? ["-p", parent] : []), "-m", message);
 
@@ -183,7 +200,7 @@ describe("ci serve records each merge unless apply on merge is opted in (#4168)"
   test("a merge to the target branch gets the record job, measured from the head before it, and no resume record", async () => {
     const { root, app, main } = workspace();
     const forge = fakeForge(main);
-    const { opts, events, state } = serve(app, forge, { applyOnMerge: false });
+    const { opts, events, state } = serve(app, forge);
     await ciServePass(opts);
     const merged = commit(root, "app/merged.txt");
     git(root, "push", "-q", "origin", "main");
@@ -209,7 +226,6 @@ describe("ci serve records each merge unless apply on merge is opted in (#4168)"
     const ticks: string[] = [];
     let fail = false;
     const { opts, events } = serve(app, forge, {
-      applyOnMerge: false,
       tick: async () => {
         ticks.push("tick");
         if (fail) throw new Error("forge said no");
@@ -267,28 +283,49 @@ describe("chant ci serve (#4095)", () => {
     expect(forge.polls).toBe(2);
   });
 
-  test("a merge to the target branch applies the new commit, measured from the head before it", async () => {
-    const { root, app, main } = workspace();
+  test("under apply on merge a merge gets the record job, and the newest green commit the apply, once (#4168 step 9)", async () => {
+    const { root, app, main } = greenWorkspace();
     const forge = fakeForge(main);
-    const { opts, events } = serve(app, forge);
+    const { opts, events } = serve(app, forge, { applyOnMerge: true });
     expect((await ciServePass(opts)).jobs).toEqual([]);
     expect(ofType(events, "baseline")).toHaveLength(1);
 
     const merged = commit(root, "app/merged.txt");
     git(root, "push", "-q", "origin", "main");
     forge.head = merged;
+    // Not green yet: the merge is recorded, and nothing applies.
+    const recorded = await ciServePass(opts);
+    expect(recorded.jobs).toEqual([expect.objectContaining({ job: "record", commit: merged, base: main, status: "ok" })]);
+
+    tagGreen(root, merged);
     const pass = await ciServePass(opts);
-    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", commit: merged, base: main, status: "ok" })]);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", commit: merged, status: "ok" })]);
+    expect(pass.jobs[0]!.pr).toBeUndefined();
     const argv = argsOf(pass.jobs[0]!.report!, "pr-apply");
-    expect(argv.slice(0, 4)).toEqual(["components", "pr-apply", "--base", main]);
+    expect(argv.slice(0, 3)).toEqual(["components", "pr-apply", "--green"]);
+    expect(argv).not.toContain("--base");
     expect(argv.slice(-2)).toEqual(["--resume", ".chant/pr-resume/pr-apply.json"]);
     // The run was recorded on chant/lifecycle and pushed.
     expect(git(root, "ls-remote", "origin", "chant/lifecycle")).toContain(git(root, "rev-parse", "chant/lifecycle"));
-
+    // The green commit is applied once, and the branch head the serve tracks stays the merge's.
     expect((await ciServePass(opts)).jobs).toEqual([]);
+    const saved = readCiServeState(join(opts.stateDir!, `${prApplyGroup("prod", "app")}.json`), { forge: "forgejo", repo: "demo/estate", env: "prod", branch: "main" });
+    expect(saved.target).toBe(merged);
   });
 
-  test("an apply gets the number of the pull request whose merge commit it is (#4112)", async () => {
+  test("without ci.green apply on merge has nothing to apply, and the merge is recorded", async () => {
+    const { root, app, main } = workspace();
+    const forge = fakeForge(main);
+    const { opts } = serve(app, forge, { applyOnMerge: true });
+    await ciServePass(opts);
+    const merged = commit(root, "app/merged.txt");
+    git(root, "push", "-q", "origin", "main");
+    forge.head = merged;
+    tagGreen(root, merged);
+    expect((await ciServePass(opts)).jobs).toEqual([expect.objectContaining({ job: "record", commit: merged, status: "ok" })]);
+  });
+
+  test("a record gets the number of the pull request whose merge commit it is (#4112)", async () => {
     const { root, app, main } = workspace();
     const forge = fakeForge(main);
     const seen: Array<number | undefined> = [];
@@ -301,7 +338,7 @@ describe("chant ci serve (#4095)", () => {
 
     const pass = await ciServePass(opts);
     expect(forge.asked).toEqual([merged]);
-    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", commit: merged, pr: 17, status: "ok" })]);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "record", commit: merged, pr: 17, status: "ok" })]);
     expect(seen).toEqual([17]);
   });
 
@@ -315,25 +352,25 @@ describe("chant ci serve (#4095)", () => {
     return { root, forge, seen, opts };
   }
 
-  test("an apply with no pull request found runs without --pr (#4112)", async () => {
+  test("a record with no pull request found runs without --pr (#4112)", async () => {
     const { root, forge, seen, opts } = await mergeWithoutPr();
     const direct = commit(root, "app/direct.txt");
     git(root, "push", "-q", "origin", "main");
     forge.head = direct;
     const pass = await ciServePass(opts);
-    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", commit: direct, status: "ok" })]);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "record", commit: direct, status: "ok" })]);
     expect(pass.jobs[0]!.pr).toBeUndefined();
     expect(seen).toEqual([undefined]);
   });
 
-  test("an apply whose pull request lookup fails runs without --pr (#4112)", async () => {
+  test("a record whose pull request lookup fails runs without --pr (#4112)", async () => {
     const { root, forge, seen, opts } = await mergeWithoutPr();
     const broken = commit(root, "app/broken.txt");
     git(root, "push", "-q", "origin", "main");
     forge.head = broken;
     forge.merges.set(broken, "throw");
     const pass = await ciServePass(opts);
-    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", commit: broken, status: "ok" })]);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "record", commit: broken, status: "ok" })]);
     expect(pass.jobs[0]!.pr).toBeUndefined();
     expect(seen).toEqual([undefined]);
   });
@@ -353,13 +390,12 @@ describe("chant ci serve (#4095)", () => {
   });
 
   test("the group's lease held elsewhere holds the apply until it is released", async () => {
-    const { root, app, main } = workspace();
+    const { root, app, main } = greenWorkspace();
     const forge = fakeForge(main);
-    const { opts, events } = serve(app, forge);
-    await ciServePass(opts);
-    const merged = commit(root, "app/merged.txt");
-    git(root, "push", "-q", "origin", "main");
-    forge.head = merged;
+    // The branch head is the green commit from the first poll, so only the apply is due.
+    const merged = main;
+    tagGreen(root, merged);
+    const { opts, events } = serve(app, forge, { applyOnMerge: true });
 
     const group = prApplyGroup("prod", "app");
     const other = await acquireLease(group, "other-host", { cwd: app, mode: "claim", requirePush: true });
@@ -371,7 +407,7 @@ describe("chant ci serve (#4095)", () => {
 
     expect(await releaseLease(group, "other-host", other.lease!.token, { cwd: app })).toBe(true);
     const ran = await ciServePass(opts);
-    expect(ran.jobs).toEqual([expect.objectContaining({ job: "apply", commit: merged, base: main, status: "ok" })]);
+    expect(ran.jobs).toEqual([expect.objectContaining({ job: "apply", commit: merged, status: "ok" })]);
     // The serve released its own lease after the apply.
     expect((await acquireLease(group, "after", { cwd: app, mode: "claim" })).acquired).toBe(true);
   });
@@ -387,13 +423,11 @@ describe("chant ci serve (#4095)", () => {
     let record: string;
 
     beforeAll(async () => {
-      w = workspace();
+      w = greenWorkspace();
       forge = fakeForge(w.main);
-      failing = serve(w.app, forge, { hostEnv: { FAKE_EXIT: "3", FAKE_ATTEMPT: "1" } });
-      await ciServePass(failing.opts);
-      merged = commit(w.root, "app/merged.txt");
-      git(w.root, "push", "-q", "origin", "main");
-      forge.head = merged;
+      merged = w.main;
+      tagGreen(w.root, merged);
+      failing = serve(w.app, forge, { applyOnMerge: true, hostEnv: { FAKE_EXIT: "3", FAKE_ATTEMPT: "1" } });
       failed = await ciServePass(failing.opts);
       record = join(failing.state, "resume", `${prApplyRecordKey("prod", merged, "app")}.json`);
     });
@@ -408,9 +442,9 @@ describe("chant ci serve (#4095)", () => {
     });
 
     test("--rerun-failed runs it again with its resume record", async () => {
-      const retry = serve(w.app, forge, { stateDir: failing.state, rerunFailed: true, hostEnv: { FAKE_EXIT: "0", FAKE_ATTEMPT: "2" } });
+      const retry = serve(w.app, forge, { applyOnMerge: true, stateDir: failing.state, rerunFailed: true, hostEnv: { FAKE_EXIT: "0", FAKE_ATTEMPT: "2" } });
       const again = await ciServePass(retry.opts);
-      expect(again.jobs).toEqual([expect.objectContaining({ job: "apply", commit: merged, base: w.main, status: "ok", attempts: 2 })]);
+      expect(again.jobs).toEqual([expect.objectContaining({ job: "apply", commit: merged, status: "ok", attempts: 2 })]);
       expect(ofType(retry.events, "started")[0]).toMatchObject({ attempt: 2, resume: record });
       // The job read the first attempt's record, and left its own.
       expect(JSON.parse(readFileSync(join(again.jobs[0]!.report!, "resume-in.json"), "utf-8"))).toEqual({ attempt: "1" });
@@ -450,7 +484,7 @@ describe("chant ci serve (#4095)", () => {
 });
 
 describe("ci serve follows the forge's chant/lifecycle (#4121)", () => {
-  /** A serve past its baseline pass, with one merge waiting to apply, and each run's result in `results`. */
+  /** A serve past its baseline pass, with one merge waiting to be recorded, and each run's result in `results`. */
   async function mergeWaiting() {
     const w = workspace();
     const seed = seedLedger(w.root);
@@ -464,14 +498,14 @@ describe("ci serve follows the forge's chant/lifecycle (#4121)", () => {
     return { ...w, seed, opts, events, results };
   }
 
-  test("a ledger the forge deleted is deleted here, and the next apply runs clean", async () => {
+  test("a ledger the forge deleted is deleted here, and the next job runs clean", async () => {
     const { root, origin, seed, opts, events, results } = await mergeWaiting();
     git(origin, "update-ref", "-d", "refs/heads/chant/lifecycle");
 
     const pass = await ciServePass(opts);
     expect(ofType(events, "ledger")).toEqual([{ type: "ledger", action: "deleted", local: seed }]);
     expect(formatCiServeEvent(ofType(events, "ledger")[0]!)).toContain("was deleted");
-    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", status: "ok" })]);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "record", status: "ok" })]);
     expect(results[0]).toMatchObject({ pushed: true });
     const tip = git(origin, "rev-parse", "refs/heads/chant/lifecycle");
     expect(git(root, "rev-parse", "chant/lifecycle")).toBe(tip);
@@ -486,28 +520,28 @@ describe("ci serve follows the forge's chant/lifecycle (#4121)", () => {
 
     const pass = await ciServePass(opts);
     expect(ofType(events, "ledger")).toEqual([{ type: "ledger", action: "reset", local: seed, forge: rewritten }]);
-    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", status: "ok" })]);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "record", status: "ok" })]);
     expect(results[0]).toMatchObject({ pushed: true });
     const tip = git(origin, "rev-parse", "refs/heads/chant/lifecycle");
     expect(isAncestor(origin, rewritten, tip)).toBe(true);
     expect(isAncestor(root, seed, tip)).toBe(false);
   });
 
-  test("a ledger ahead of the forge's keeps its facts, and the apply pushes them", async () => {
+  test("a ledger ahead of the forge's keeps its facts, and the job pushes them", async () => {
     const { root, origin, seed, opts, events, results } = await mergeWaiting();
     const ahead = ledgerCommit(root, "unpushed fact", seed);
     git(root, "update-ref", "refs/heads/chant/lifecycle", ahead);
 
     const pass = await ciServePass(opts);
     expect(ofType(events, "ledger")).toEqual([]);
-    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", status: "ok" })]);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "record", status: "ok" })]);
     expect(results[0]).toMatchObject({ pushed: true });
     expect(isAncestor(origin, ahead, git(origin, "rev-parse", "refs/heads/chant/lifecycle"))).toBe(true);
   });
 });
 
-describe("ci serve applies fast-forwards only, and honours [skip ci] (#4122)", () => {
-  test("a force push back to an older commit is recorded as seen and not applied, and the next fast-forward applies", async () => {
+describe("ci serve runs fast-forwards only, and honours [skip ci] (#4122)", () => {
+  test("a force push back to an older commit is recorded as seen and not run, and the next fast-forward is recorded", async () => {
     const { root, app, main } = workspace();
     const later = commit(root, "app/later.txt");
     git(root, "push", "-q", "origin", "main");
@@ -521,7 +555,7 @@ describe("ci serve applies fast-forwards only, and honours [skip ci] (#4122)", (
     forge.head = main;
     const back = await ciServePass(opts);
     expect(back.jobs).toEqual([]);
-    expect(ofType(events, "not-run")).toEqual([{ type: "not-run", job: "apply", commit: main, reason: "not-fast-forward", branch: "main", from: later }]);
+    expect(ofType(events, "not-run")).toEqual([{ type: "not-run", job: "record", commit: main, reason: "not-fast-forward", branch: "main", from: later }]);
     expect(formatCiServeEvent(ofType(events, "not-run")[0]!)).toContain("not a fast-forward");
     const file = join(state, `${prApplyGroup("prod", "app")}.json`);
     expect(readCiServeState(file, { forge: "forgejo", repo: "demo/estate", env: "prod", branch: "main" }).target).toBe(main);
@@ -530,10 +564,10 @@ describe("ci serve applies fast-forwards only, and honours [skip ci] (#4122)", (
     git(root, "push", "-q", "origin", "main");
     forge.head = next;
     const pass = await ciServePass(opts);
-    expect(pass.jobs).toEqual([expect.objectContaining({ job: "apply", commit: next, base: main, status: "ok" })]);
+    expect(pass.jobs).toEqual([expect.objectContaining({ job: "record", commit: next, base: main, status: "ok" })]);
   });
 
-  test("a target head whose message says [skip ci] is recorded as seen and not applied", async () => {
+  test("a target head whose message says [skip ci] is recorded as seen and not run", async () => {
     const { root, app, main } = workspace();
     const forge = fakeForge(main);
     const { opts, events, state } = serve(app, forge);
@@ -543,7 +577,7 @@ describe("ci serve applies fast-forwards only, and honours [skip ci] (#4122)", (
     forge.head = skip;
 
     expect((await ciServePass(opts)).jobs).toEqual([]);
-    expect(ofType(events, "not-run")).toEqual([{ type: "not-run", job: "apply", commit: skip, reason: "skip-ci" }]);
+    expect(ofType(events, "not-run")).toEqual([{ type: "not-run", job: "record", commit: skip, reason: "skip-ci" }]);
     expect(formatCiServeEvent(ofType(events, "not-run")[0]!)).toContain("says [skip ci]");
     const file = join(state, `${prApplyGroup("prod", "app")}.json`);
     expect(readCiServeState(file, { forge: "forgejo", repo: "demo/estate", env: "prod", branch: "main" }).target).toBe(skip);