@intentius/chant 0.124.31 → 0.124.32

package/src/op/op-waves-run.ts

@@ -68,6 +68,7 @@ import type { GateAnswerRef, PendingGateRecord } from "../lifecycle/gate-ledger"
 import type { GatePointAsker } from "../point-decision";
 import type { WaitingPoint } from "./steward-points";
 import { isApprovalSpent, type AppliedGateRecord } from "../lifecycle/gate-applied";
+import { isLifecycleLocalNote } from "../lifecycle/local-note";
 import type { HeadPlans, MergedReview, ReviewSource } from "./gate-review";
 import type { TrustPolicy } from "../workspace/trust/policy";
 import type { GateSigners } from "../workspace/trust/gate-seal";
@@ -1721,11 +1722,22 @@ async function settleDenials(ctx: WaveContext, decision: OpWaveDecision, listed:
   }
 }
 
+/**
+ * Throws unless a spend's record reached the remote the next run reads
+ * (#3985). Without that, the next run reads the approval or override as
+ * unspent. A ledger with no remote is the whole ledger, so a line recorded
+ * there is spent.
+ */
+function requireSpendPushed(result: { pushed: boolean; pushWarning?: string }): void {
+  if (result.pushed || isLifecycleLocalNote(result.pushWarning)) return;
+  throw new Error(`the record did not reach the remote the next run reads: ${result.pushWarning ?? "the push did not land"}`);
+}
+
 /**
  * Record each override the wave is about to apply under (#3821), in
  * `_gates/policy-override/applied.jsonl`, which spends it: written before
- * anything applies, once. False when the lines could not be written: the
- * wave then fails and applies nothing.
+ * anything applies, once. False when the lines could not be written or did
+ * not reach the remote (#3985): the wave then fails and applies nothing.
  */
 async function spendOverrides(ctx: WaveContext, decision: OpWaveDecision): Promise<boolean> {
   const used = decision.members.filter((m) => m.override);
@@ -1738,7 +1750,7 @@ async function spendOverrides(ctx: WaveContext, decision: OpWaveDecision): Promi
     if (!port.appendApplied) throw new Error("this gate ledger cannot record an applied override");
     for (const m of used) {
       const record = og.appliedOverride({ subject: m.member, digest: m.override!.digest, at: m.override!.at, by: m.override!.by }, { timestamp: now });
-      await port.appendApplied(record as unknown as AppliedGateRecord);
+      requireSpendPushed(await port.appendApplied(record as unknown as AppliedGateRecord));
     }
   } catch (err) {
     failed(ctx, `wave ${k} (${wave.name}) could not record the overrides it applies under, so nothing applied: ${err instanceof Error ? err.message : String(err)}`);
@@ -2153,9 +2165,11 @@ async function applyStage(
  * Record that the wave applies under its approval (#3784), which spends it:
  * one line in `_gates/<name>/applied.jsonl`, before anything applies, as
  * terragucci's wave gate writes it. Only an approved wave under the spend
- * rule records, and only once. False when the line could not be written: the
+ * rule records, and only once. False when the line could not be written, or
+ * was written but did not reach the remote the next run reads (#3985): the
  * wave then fails and applies nothing, since an apply the record misses
- * would leave its approval standing.
+ * would leave its approval standing. A ledger with no remote is the whole
+ * ledger, so a line recorded there is spent.
  */
 async function spendApproval(options: RunOpWaveOptions, ctx: WaveContext, decision: OpWaveDecision): Promise<boolean> {
   if (!decision.spend || decision.status !== "approved" || decision.spentAt || !decision.approvedAt) return true;
@@ -2177,6 +2191,7 @@ async function spendApproval(options: RunOpWaveOptions, ctx: WaveContext, decisi
   try {
     if (!port.appendApplied) throw new Error("this gate ledger cannot record an applied approval");
     const pushed = await port.appendApplied(record);
+    requireSpendPushed(pushed);
     if (!pushed.pushed && pushed.pushWarning) log(`wave ${k} (${wave.name}): ${pushed.pushWarning}`);
   } catch (err) {
     failed(ctx, `wave ${k} (${wave.name}) could not record that it applies under the approval by ${record.approvedBy}, so nothing applied: ${err instanceof Error ? err.message : String(err)}`);

package/src/op/op-waves.test.ts

@@ -17,6 +17,8 @@ import {
 } from "./op-waves-run";
 import { memoryGateLedgerPort } from "./gate";
 import { waveSetDigest } from "../gated-waves";
+import type { AppliedGateRecord } from "../lifecycle/gate-applied";
+import { LIFECYCLE_LOCAL_NOTE } from "../lifecycle/local-note";
 
 const spec: OpWavesSpec = {
   name: "migrations",
@@ -475,6 +477,39 @@ describe("spent approvals (#3784)", () => {
     h.done();
   });
 
+  test("a spend whose record does not reach the remote applies nothing, and the approval stays unspent (#3985)", async () => {
+    const h = harness(spending);
+    const memory = memoryGateLedgerPort({ resolutions: [approval] });
+    const gates = {
+      ...memory,
+      async appendApplied(record: AppliedGateRecord) {
+        await memory.appendApplied!(record);
+        return { pushed: false, pushWarning: 'the push of chant/lifecycle to "origin" failed' };
+      },
+    };
+    const result = await runOpWave({ spec: spending, specFile: "waves.json", wave: 2, cwd: h.cwd, exec: h.exec, show: h.show, gates, now: "2026-10-11T00:00:00Z" });
+    expect(result).toMatchObject({ exitCode: 1, applied: [] });
+    expect(result.decision?.spentAt).toBeUndefined();
+    expect(h.applies()).toBe(0);
+    h.done();
+  });
+
+  test("with no remote the local ledger is the whole ledger, so a spend recorded there applies (#3985)", async () => {
+    const h = harness(spending);
+    const memory = memoryGateLedgerPort({ resolutions: [approval] });
+    const gates = {
+      ...memory,
+      async appendApplied(record: AppliedGateRecord) {
+        await memory.appendApplied!(record);
+        return { pushed: false, pushWarning: LIFECYCLE_LOCAL_NOTE };
+      },
+    };
+    const result = await runOpWave({ spec: spending, specFile: "waves.json", wave: 2, cwd: h.cwd, exec: h.exec, show: h.show, gates, now: "2026-10-11T00:00:00Z" });
+    expect(result).toMatchObject({ exitCode: 0, decision: { status: "approved", spentAt: "2026-10-11T00:00:00Z" } });
+    expect(memory.applied).toHaveLength(1);
+    h.done();
+  });
+
   test("a wave that cannot record the approval applies nothing", async () => {
     const h = harness(spending);
     const gates = { ...memoryGateLedgerPort({ resolutions: [approval] }), appendApplied: undefined };
@@ -878,6 +913,20 @@ describe("gates and holds a product's wave needs (#3821)", () => {
     other.done();
   });
 
+  test("an override spend whose record does not reach the remote applies nothing (#3985)", async () => {
+    const { overrideDigest } = await import("../override-gate");
+    const od = overrideDigest("vpc", digest("1"), ["no-public-s3"]);
+    const h = harness({ vpc: { planDigest: digest("1"), denied: { rules: ["no-public-s3"] } }, dns: { planDigest: digest("2"), empty: true } }, { extra: { overriders: ["github:carol"] }, atBase: { ...tg, waves: [{ ...tg.waves[0]!, gate: "never" }] } });
+    const memory = memoryGateLedgerPort({
+      resolutions: [{ version: 1, op: "policy-override", gate: "vpc", resolvedBy: "github:carol", timestamp: "2026-10-10T00:00:00Z", planDigest: od, note: "the bucket is the public docs site" }],
+    });
+    const gates = { ...memory, appendApplied: async () => ({ pushed: false, pushWarning: 'the push of chant/lifecycle to "origin" failed' }) };
+    const result = await run(h, gates);
+    expect(result).toMatchObject({ exitCode: 1, applied: [] });
+    expect(h.calls.some((c) => c.startsWith("tg apply"))).toBe(false);
+    h.done();
+  });
+
   test("a plans file's overridersSource names the list in the refusal and the decision record (#3848)", async () => {
     const mk = (extra: Record<string, unknown>) => harness({ vpc: { planDigest: digest("1"), denied: { rules: ["no-public-s3"] } }, dns: { planDigest: digest("2") } }, { extra });
     const logs: string[] = [];

package/src/op/operator.ts

@@ -399,8 +399,8 @@ const STEWARD_TURN_POLL_MS = 150;
  *
  * Contention never queues past `waitMs` (0 by default): consistent with a
  * round's own leases, which skip and report rather than wait (see this
- * module's doc), and with the fountain form, whose busy teammate is likewise
- * refused rather than retried. A caller that wants to ride out a race with a
+ * module's doc), and with the fountain form, whose busy steward conversation
+ * is likewise refused rather than retried. A caller that wants to ride out a race with a
  * turn about to end passes `waitMs`, and this polls every
  * {@link STEWARD_TURN_POLL_MS} until it acquires or the wait runs out.
  */

package/src/op/steward.ts

@@ -5,9 +5,11 @@
  * A steward runs a fixed list of Ops, each on its own `schedule` when it has
  * one, one Op at a time. Where it runs is its form:
  *
- * - `fountain`: the fountain lexicon's `Steward` composite, an `acp` Agent on
- *   a persistent sandbox bound to a Teammate, with a Fountain `Schedule` per
- *   scheduled Op. A turn is one `chant run <op>` on the teammate's thread.
+ * - `fountain`: the fountain lexicon's `Steward` composite, an `acp` Agent
+ *   whose runs `chant run <op> --on fountain` sends to one long-lived
+ *   conversation, resumed by channel_id. A turn is one `chant run <op>` in
+ *   that conversation. Managoat has no scheduler, so a scheduled Op's cron
+ *   fires from a clock outside it (a CI schedule, a CronJob).
  * - `local`: `chant operator --steward <name>` in the box itself, for a box
  *   with no Fountain behind it (a docker compose box, a Sprites box). The same
  *   Ops on the same crons, each run under its operator lease, and the steward
@@ -129,7 +131,7 @@ export interface StewardBeside {
 }
 
 export interface StewardDeclarationConfig {
-  /** The steward's name. On Fountain, the Agent's and the Teammate's. */
+  /** The steward's name. On Fountain, the Agent's, and the key of its conversation. */
   name: string;
   /** The Ops it runs. A scheduled one runs on its cron; any other runs when asked. */
   ops: StewardOpInput[];

package/src/op/work-lease-run.test.ts

@@ -342,9 +342,10 @@ describe("an Op that changes the checkout", () => {
       expect(result.workLease).toMatchObject({ item: "W-7", branch: "chant/work/W-7", released: true, outcome: "done" });
       expect(result.workLease?.holder).toBe(stewardWorkHolder("box", "dispatch", "h1"));
 
-      // The worktree sat under the git directory and is gone; the branch keeps the build.
-      expect(worktree.startsWith(join(dir, ".git"))).toBe(true);
+      // The worktree sat at .chant/work/<item> in the checkout and is gone, with the directories it left empty; the branch keeps the build.
+      expect(worktree).toBe(join(dir, ".chant", "work", "W-7"));
       expect(existsSync(worktree)).toBe(false);
+      expect(existsSync(join(dir, ".chant"))).toBe(false);
       expect(git(["show", "chant/work/W-7:app/feature.ts"], dir).stdout).toBe("export const feature = true;\n");
 
       // The coding agent's checkout: its edit, its lock, HEAD and the index, as they were.
@@ -403,3 +404,88 @@ describe("an Op that changes the checkout", () => {
     });
   });
 });
+
+describe("where the worktree is (#2893)", () => {
+  const record = (seen: { worktree?: string; status?: string }) =>
+    new Map<string, ActivityFn>([
+      [
+        "build",
+        async (args) => {
+          seen.worktree = String(args.worktree);
+          writeFileSync(join(seen.worktree, "app", "feature.ts"), "export const feature = true;\n");
+          seen.status = git(["status", "--porcelain", "--untracked-files=all"], dir()).stdout;
+          return {};
+        },
+      ],
+    ]);
+  let current = "";
+  const dir = () => current;
+  const op = (item: string) => dispatchOp({ workLease: { item }, changesCheckout: true }, [step("build", { worktree: workLeaseOutput("worktree") })]);
+
+  test("it is .chant/work/<item> in the checkout, info/exclude gets /.chant/work/ once, and git status stays clean while it is there", async () => {
+    await withTestDir(async (d) => {
+      current = d;
+      await initRepo(d);
+      const seen: { worktree?: string; status?: string } = {};
+      const first = await run(op("W-20"), record(seen), d);
+      expect(first.workLease).toMatchObject({ released: true, outcome: "done" });
+      expect(seen.worktree).toBe(join(d, ".chant", "work", "W-20"));
+      expect(seen.status).toBe("");
+      const exclude = () => readFileSync(join(d, ".git", "info", "exclude"), "utf-8").split("\n").filter((l) => l === "/.chant/work/");
+      expect(exclude()).toHaveLength(1);
+      await run(op("W-21"), record(seen), d);
+      expect(exclude()).toHaveLength(1);
+      expect(git(["status", "--porcelain", "--untracked-files=all"], d).stdout).toBe("");
+      expect(git(["worktree", "list", "--porcelain"], d).stdout).not.toContain(".chant/work");
+    });
+  });
+
+  test("info/exclude is left alone when the project already ignores .chant/work", async () => {
+    await withTestDir(async (d) => {
+      current = d;
+      await initRepo(d);
+      writeFileSync(join(d, ".gitignore"), ".chant/\n");
+      git(["add", ".gitignore"], d);
+      git(["commit", "-q", "-m", "ignore"], d);
+      const before = existsSync(join(d, ".git", "info", "exclude")) ? readFileSync(join(d, ".git", "info", "exclude"), "utf-8") : "";
+      const seen: { worktree?: string; status?: string } = {};
+      await run(op("W-22"), record(seen), d);
+      expect(seen.status).toBe("");
+      const after = existsSync(join(d, ".git", "info", "exclude")) ? readFileSync(join(d, ".git", "info", "exclude"), "utf-8") : "";
+      expect(after).toBe(before);
+    });
+  });
+
+  test("a worktree a crashed run left under .git/chant-work with the branch checked out is removed, and the run goes on from the branch", async () => {
+    await withTestDir(async (d) => {
+      current = d;
+      await initRepo(d);
+      const old = join(d, ".git", "chant-work", "W-23");
+      expect(git(["worktree", "add", "-q", "-b", "chant/work/W-23", old, "HEAD"], d).status).toBe(0);
+      writeFileSync(join(old, "app", "earlier.ts"), "export const earlier = 1;\n");
+      git(["add", "-A"], old);
+      git(["commit", "-q", "-m", "an earlier run"], old);
+      const seen: { worktree?: string; status?: string } = {};
+      const result = await run(op("W-23"), record(seen), d);
+      expect(result.workLease).toMatchObject({ released: true, outcome: "done" });
+      expect(seen.worktree).toBe(join(d, ".chant", "work", "W-23"));
+      expect(existsSync(old)).toBe(false);
+      expect(git(["worktree", "list", "--porcelain"], d).stdout).not.toContain("chant-work");
+      expect(git(["show", "chant/work/W-23:app/earlier.ts"], d).stdout).toBe("export const earlier = 1;\n");
+    });
+  });
+
+  test("a worktree a crashed run left at .chant/work with the branch checked out is replaced", async () => {
+    await withTestDir(async (d) => {
+      current = d;
+      await initRepo(d);
+      const left = join(d, ".chant", "work", "W-24");
+      expect(git(["worktree", "add", "-q", "-b", "chant/work/W-24", left, "HEAD"], d).status).toBe(0);
+      writeFileSync(join(left, "app", "stray.ts"), "stray\n");
+      const seen: { worktree?: string; status?: string } = {};
+      const result = await run(op("W-24"), record(seen), d);
+      expect(result.workLease).toMatchObject({ released: true, outcome: "done" });
+      expect(existsSync(left)).toBe(false);
+    });
+  });
+});

package/src/op/work-lease-run.ts

@@ -39,10 +39,11 @@
  *
  * An Op with `changesCheckout` (applying a build, `chant workspace upgrade`)
  * must declare `workLease`, and its leased steps get a git worktree of their
- * own: `chant/work/<item>` checked out under the repository's git directory,
- * from the checkout's HEAD, or from the branch as an earlier run left it. The
- * worktree is removed when the run ends and the branch keeps whatever the
- * steps committed, for the runner to deliver. The checkout a coding agent is
+ * own: `chant/work/<item>` checked out at `.chant/work/<item>` in the
+ * checkout (#2893), which `<git-common-dir>/info/exclude` keeps out of
+ * `git status`, from the checkout's HEAD or from the branch as an earlier run
+ * left it. The worktree is removed when the run ends and the branch keeps
+ * whatever the steps committed, for the runner to deliver. The checkout a coding agent is
  * editing, its index and its uncommitted files, are never touched.
  *
  * A run that ends `not_done` keeps its attempt aside (#3147): whatever the
@@ -54,7 +55,7 @@
  */
 
 import { existsSync, rmSync } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
+import { isAbsolute, resolve, sep } from "node:path";
 import { getRuntime } from "../runtime-adapter";
 import {
   claimWorkLease,
@@ -69,6 +70,7 @@ import {
   type WorkLease,
 } from "../lifecycle/work-lease";
 import { resolveMemberLedger } from "../lifecycle/member-ledger";
+import { excludeWorkDir, legacyWorkWorktreePath, LEGACY_WORK_DIR, removeEmptyWorkDirs, WORK_DIR, workWorktreePath } from "../lifecycle/work-dir";
 import { currentHolderId } from "../lifecycle/lease";
 import { parseDuration } from "./duration";
 import { isStepOutputRef, stepOutput, type StepOutputRef } from "./step-output-ref";
@@ -271,21 +273,36 @@ export class RunWorkLease {
   }
 
   /**
-   * A worktree for `id` on `chant/work/[<member>/]<id>`, under the git
-   * directory so the checkout's own `git status` never lists it. Starts from
-   * the branch when an earlier run left it, from HEAD otherwise.
+   * A worktree for `id` on `chant/work/[<member>/]<id>`, at
+   * `<checkout>/.chant/work/[<member>/]<id>` (#2893): inside the checkout, so
+   * a coding agent may write there and `node_modules` resolves, and in
+   * `<git-common-dir>/info/exclude`, so the checkout's own `git status` never
+   * lists it. Starts from the branch when an earlier run left it, from HEAD
+   * otherwise. A worktree an earlier run left on the branch, here or where
+   * older versions made it under the git directory, is removed first.
    */
   private async makeWorktree(id: string, members: readonly string[]): Promise<{ worktree: string; branch: string }> {
     const cwd = this.opts.cwd;
     const common = await git(["rev-parse", "--git-common-dir"], cwd);
     if (!common.ok) throw new Error(`Op "${this.config.name}" changes the checkout, but ${cwd} is not a git checkout: ${common.stderr}`);
     const commonDir = isAbsolute(common.stdout) ? common.stdout : resolve(cwd, common.stdout);
+    // The top as the caller spells it (git's --show-toplevel resolves symbolic links).
+    const cdup = await git(["rev-parse", "--show-cdup"], cwd);
+    if (!cdup.ok) throw new Error(`Op "${this.config.name}" changes the checkout, but ${cwd} has no working tree: ${cdup.stderr}`);
+    const top = resolve(cwd, cdup.stdout);
     const scope = members.join("/");
     const branch = `${WORK_BRANCH_PREFIX}${scope ? `${scope}/` : ""}${id}`;
-    const worktree = join(commonDir, "chant-work", ...members, id);
-    if (existsSync(worktree)) {
-      await git(["worktree", "remove", "--force", worktree], cwd);
-      rmSync(worktree, { recursive: true, force: true });
+    const worktree = workWorktreePath(top, members, id);
+    const ignored = (await git(["check-ignore", "-q", `${WORK_DIR}/${id}`], top)).ok;
+    excludeWorkDir(commonDir, ignored);
+    for (const stale of await this.staleWorktrees(branch, commonDir, members, id)) {
+      await git(["worktree", "remove", "--force", stale], cwd);
+      rmSync(stale, { recursive: true, force: true });
+    }
+    for (const dir of [worktree, legacyWorkWorktreePath(commonDir, members, id)]) {
+      if (!existsSync(dir)) continue;
+      await git(["worktree", "remove", "--force", dir], cwd);
+      rmSync(dir, { recursive: true, force: true });
     }
     await git(["worktree", "prune"], cwd);
     const exists = (await git(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], cwd)).ok;
@@ -298,6 +315,28 @@ export class RunWorkLease {
     return { worktree, branch };
   }
 
+  /**
+   * The registered worktrees that have `branch` checked out at a path chant
+   * makes work worktrees at: `.chant/work/[<member>/]<id>` in any checkout,
+   * or `<git-common-dir>/chant-work/[<member>/]<id>` where versions before
+   * #2893 made them. A run that crashed leaves one behind, and `git worktree
+   * add` then refuses the branch as already checked out.
+   */
+  private async staleWorktrees(branch: string, commonDir: string, members: readonly string[], id: string): Promise<string[]> {
+    const list = await git(["worktree", "list", "--porcelain"], this.opts.cwd);
+    if (!list.ok) return [];
+    const tail = [...members, id].join("/");
+    const legacy = legacyWorkWorktreePath(commonDir, members, id).split(sep).join("/");
+    const out: string[] = [];
+    for (const block of list.stdout.split(/\n\s*\n/)) {
+      const path = /^worktree (.+)$/m.exec(block)?.[1];
+      if (!path || !block.split("\n").includes(`branch refs/heads/${branch}`)) continue;
+      const posixPath = path.split(sep).join("/");
+      if (posixPath.endsWith(`/${WORK_DIR}/${tail}`) || posixPath === legacy || posixPath.endsWith(`/${LEGACY_WORK_DIR}/${tail}`)) out.push(path);
+    }
+    return out;
+  }
+
   private lose(why: string): void {
     if (this.lost !== undefined) return;
     this.lost = why;
@@ -408,6 +447,7 @@ export class RunWorkLease {
     if (lease.worktree) {
       await git(["worktree", "remove", "--force", lease.worktree], this.opts.cwd).catch(() => undefined);
       rmSync(lease.worktree, { recursive: true, force: true });
+      removeEmptyWorkDirs(lease.worktree);
       await git(["worktree", "prune"], this.opts.cwd).catch(() => undefined);
     }
     if (this.lost !== undefined) return base;

package/src/pr-forge-bundle.test.ts

@@ -34,7 +34,7 @@ describe("the pr-forge bundle", () => {
       expect(inputs.filter((i) => pattern.test(i)), String(pattern)).toEqual([]);
     }
     expect(inputs.map((i) => i.replace(/^.*?packages\//, "packages/")).sort()).toEqual(["packages/core/src/pr-forge.ts"]);
-    // About 27 KB today.
-    expect(result.outputFiles.reduce((n, f) => n + f.contents.byteLength, 0)).toBeLessThan(32 * 1024);
+    // About 33 KB today, after the pull request authors (#4000).
+    expect(result.outputFiles.reduce((n, f) => n + f.contents.byteLength, 0)).toBeLessThan(36 * 1024);
   });
 });

package/src/pr-forge.test.ts

@@ -85,6 +85,21 @@ describe("github", () => {
     expect(calls[0].body).toEqual({ state: "success", context: "chant/plan", description: "2 members", target_url: "https://ci/run/1" });
   });
 
+  test("the authors of a pull request are its opener and every commit's author and committer, every page read (#4000)", async () => {
+    const page1 = Array.from({ length: 100 }, () => ({ author: { login: "carol" }, committer: { login: "carol" } }));
+    const { fetch, calls } = fakeFetch({
+      "GET /repos/acme/infra/pulls/12": { number: 12, user: { login: "carol" } },
+      "GET /repos/acme/infra/pulls/12/commits?page=1": page1,
+      "GET /repos/acme/infra/pulls/12/commits?page=2": [{ author: null, committer: { login: "dave" } }, { author: { login: "erin" }, committer: { login: "web-flow" } }],
+    });
+    expect(await githubForge({ ...opts, fetch }).authors(12)).toEqual(["carol", "dave", "erin", "web-flow"]);
+    expect(calls.map((c) => c.url)).toEqual([
+      "https://api.github.com/repos/acme/infra/pulls/12",
+      "https://api.github.com/repos/acme/infra/pulls/12/commits?per_page=100&page=1",
+      "https://api.github.com/repos/acme/infra/pulls/12/commits?per_page=100&page=2",
+    ]);
+  });
+
   test("an approver is someone whose newest deciding review approves", async () => {
     const { fetch } = fakeFetch({
       "GET /repos/acme/infra/pulls/12/reviews": [
@@ -195,6 +210,15 @@ describe("forgejo", () => {
     expect(calls[0].headers.Authorization).toBe("token t0k");
   });
 
+  test("the authors of a pull request come from the same endpoints, paged by limit (#4000)", async () => {
+    const { fetch, calls } = fakeFetch({
+      "GET /api/v1/repos/acme/infra/pulls/4": { number: 4, user: { login: "ana" } },
+      "GET /api/v1/repos/acme/infra/pulls/4/commits": [{ author: { login: "ana" }, committer: { login: "ben" } }],
+    });
+    expect(await forgejoForge({ ...opts, fetch }).authors(4)).toEqual(["ana", "ben"]);
+    expect(calls.map((c) => c.url)).toContain("https://codeberg.org/api/v1/repos/acme/infra/pulls/4/commits?limit=50&page=1");
+  });
+
   test("a dismissed approval no longer counts, and a comment review decides nothing", async () => {
     const { fetch } = fakeFetch({
       "GET /api/v1/repos/acme/infra/pulls/4/reviews": [
@@ -240,6 +264,24 @@ describe("gitlab", () => {
     expect(calls[0].body).toEqual({ state: "failed", name: "chant/apply", description: "refused" });
   });
 
+  test("the authors of a merge request: its author, and each commit email's account by the users search (#4000)", async () => {
+    const { fetch, calls } = fakeFetch({
+      "GET /api/v4/projects/42/merge_requests/5": { iid: 5, author: { username: "ana" } },
+      "GET /api/v4/projects/42/merge_requests/5/commits": [
+        { author_email: "ana@example.com", committer_email: "Ben@Example.com" },
+        { author_email: "ghost@example.com", committer_email: "ana@example.com" },
+      ],
+      "GET /api/v4/users": (c: Call) =>
+        ({ "ana@example.com": [{ username: "ana" }], "ben@example.com": [{ username: "ben" }] })[new URL(c.url).searchParams.get("search")!] ?? [],
+    });
+    expect(await gitlabForge({ ...opts, fetch }).authors(5)).toEqual(["ana", "ben"]);
+    expect(calls.filter((c) => new URL(c.url).pathname === "/api/v4/users").map((c) => new URL(c.url).searchParams.get("search"))).toEqual([
+      "ana@example.com",
+      "ben@example.com",
+      "ghost@example.com",
+    ]);
+  });
+
   test("approvers come from the approvals endpoint, merged requests from the commit", async () => {
     const { fetch } = fakeFetch({
       "GET /api/v4/projects/42/merge_requests/5/approvals": { approved_by: [{ user: { username: "ana" } }, { user: { username: "ben" } }] },

package/src/pr-forge.ts

@@ -349,6 +349,16 @@ export interface PrForge {
   upsertIssue(marker: string, title: string, body: string): Promise<string | undefined>;
   /** Logins whose standing review approves `pr`. */
   approvers(pr: number): Promise<string[]>;
+  /**
+   * Logins of the people who wrote `pr` (#4000): its author, and the author
+   * and committer of each of its commits. GitHub and Forgejo name a commit's
+   * people by the account its email belongs to; a commit whose email is on no
+   * account adds nobody. GitLab names them by email only, so each email is
+   * looked up among the users (`GET /users?search=`), which matches an
+   * account's public email; an email no account shows publicly adds nobody.
+   * Sorted, without repeats.
+   */
+  authors(pr: number): Promise<string[]>;
   /** The merged pull request that produced `sha`, or null. */
   pullRequestFor(sha: string): Promise<number | null>;
   /**
@@ -667,6 +677,20 @@ function githubShaped(kind: "github" | "forgejo", opts: GithubForgeOptions): Git
       }
       return [...standing].filter(([, state]) => state === "APPROVED").map(([login]) => login).sort();
     },
+    async authors(pr) {
+      const logins = new Set<string>();
+      const add = (v: unknown) => {
+        if (isObject(v) && typeof v.login === "string" && v.login !== "") logins.add(v.login);
+      };
+      const opened = await api.call("GET", `${repo}/pulls/${pr}`);
+      if (isObject(opened)) add(opened.user);
+      for (const c of await api.list(`${repo}/pulls/${pr}/commits`, pageParams, pageSize)) {
+        if (!isObject(c)) continue;
+        add(c.author);
+        add(c.committer);
+      }
+      return [...logins].sort();
+    },
     async pullRequestFor(sha) {
       if (kind === "forgejo") {
         try {
@@ -922,6 +946,22 @@ export function gitlabForge(opts: GitlabForgeOptions): PrForge {
         .filter((l): l is string => l !== undefined);
       return [...new Set(logins)].sort();
     },
+    async authors(mr) {
+      const logins = new Set<string>();
+      const merge = await api.call("GET", `${notes}/${mr}`);
+      const author = isObject(merge) ? authorOf(merge) : undefined;
+      if (author) logins.add(author);
+      const emails = new Set<string>();
+      for (const c of await api.list(`${notes}/${mr}/commits`, pageParams, 100)) {
+        if (!isObject(c)) continue;
+        for (const email of [str(c.author_email), str(c.committer_email)]) if (email) emails.add(email.toLowerCase());
+      }
+      for (const email of [...emails].sort()) {
+        const users = await api.call("GET", `/users?search=${encodeURIComponent(email)}`);
+        for (const u of Array.isArray(users) ? users : []) if (isObject(u) && typeof u.username === "string") logins.add(u.username);
+      }
+      return [...logins].sort();
+    },
     async pullRequestFor(sha) {
       const mrs = await api.call("GET", `${project}/repository/commits/${sha}/merge_requests`);
       if (!Array.isArray(mrs)) return null;

package/src/pr-loop-bundle.test.ts

@@ -41,6 +41,7 @@ describe("the pull-request loop bundle", () => {
       "packages/core/src/pr-forge.ts",
       "packages/core/src/pr-loop.ts",
     ]);
-    expect(result.outputFiles.reduce((n, f) => n + f.contents.byteLength, 0)).toBeLessThan(64 * 1024);
+    // About 65 KB today, after the pull request authors (#4000).
+    expect(result.outputFiles.reduce((n, f) => n + f.contents.byteLength, 0)).toBeLessThan(72 * 1024);
   });
 });