forgedock 1.30.0 → 1.32.0

package/bin/lean/schedd.test.mjs

@@ -8,7 +8,7 @@ import { join } from "node:path";
 import { tmpDir } from "../tests/_tmp.mjs";
 import { openBatch, isLaneAlive, listBatches } from "./batch.mjs";
 import { startDaemon, scheddPaths, connectDaemon, request, mergeEnv, batchEnv } from "./schedd.mjs";
-import { formatTable } from "./orchestrate.mjs";
+import { formatTable, orchestrate } from "./orchestrate.mjs";
 import { orchestrateFromCli } from "../engine-cli.mjs";
 
 const until = async (cond, ms = 15000) => {
@@ -32,16 +32,18 @@ const a = process.argv.slice(2); const n = Number(a[1]); const rf = a[a.indexOf(
 appendFileSync(${JSON.stringify(h.launches)}, n + "\\n");
 const t = setInterval(() => { if (!existsSync(${JSON.stringify(h.release)})) return; clearInterval(t);
   writeFileSync(rf + ".tmp", JSON.stringify({ terminalReason: "merged", pr: 100 + n, cost_usd: 0 })); renameSync(rf + ".tmp", rf); }, 20);
+// Like run-issue's #4179 teardown: SIGTERM reports deferred run.interrupted.
+process.once("SIGTERM", () => { writeFileSync(rf + ".tmp", JSON.stringify({ terminalReason: "deferred", code: "run.interrupted", detail: "interrupted by SIGTERM" })); renameSync(rf + ".tmp", rf); process.exit(143); });
 `);
   h.daemonScript = join(work, "daemon.mjs");
-  writeFileSync(h.daemonScript, `import { startDaemon } from ${JSON.stringify(new URL("./schedd.mjs", import.meta.url).href)};
+  writeFileSync(h.daemonScript, `import { startDaemon, exitOnSignals } from ${JSON.stringify(new URL("./schedd.mjs", import.meta.url).href)};
 import { runBatch } from ${JSON.stringify(new URL("../engine-cli.mjs", import.meta.url).href)};
 const deps = { allowTmpfs: true, laneScript: ${JSON.stringify(stub)}, pollMs: 30, orchestration: { breaker: null, maxDeferrals: 3 }, io: { gh: async () => "o/r\\n" },
   leanIo: { gh: async (a) => a.includes("milestone") ? JSON.stringify({ milestone: null }) : a[0] === "repo" ? "main\\n" : JSON.stringify({ body: a[2] === "3" ? "Depends on #1" : "", labels: [] }),
     git: async (a) => (a[0] === "ls-remote" ? "abc\\trefs/heads/staging\\n" : "") } };
 const d = await startDaemon({ runBatch: (a) => runBatch({ ...a, daemon: true, deps }), idleMs: 600000 });
 if (!d.running) process.exit(3);
-process.once("SIGTERM", () => d.close());
+exitOnSignals(d); // the forgedock schedd handler (#4454)
 await d.closed;
 `);
   h.env = { ...process.env, FORGEDOCK_SCHED_DIR: h.sched, FORGEDOCK_BATCH_DIR: h.root, FORGEDOCK_LIMITS_FILE: join(work, "limits.json") };
@@ -151,6 +153,88 @@ await orchestrateFromCli(["1", "2", "--parallel", "2", "--repo", "o/r", "--no-pr
     } finally { h.cleanup(); }
   });
 
+  it("#4408: --add and --resume <id> N add issues to the live batch (no second batch); an unhosted finished batch runs its adds on --resume", async () => {
+    const h = host();
+    try {
+      await h.daemon();
+      const client = { ...h.client, io: { gh: async (a) => (a[0] === "issue" ? JSON.stringify({ state: a[2] === "9" ? "CLOSED" : "OPEN" }) : "o/r\n") } };
+      const { res } = await withRoot(h, () => capture(async () => {
+        const first = orchestrateFromCli(["1", "--parallel", "3", "--repo", "o/r", "--no-prefilter"], h.client);
+        await until(() => h.launched().length === 1 && h.lanePids().length === 1);
+        const [id] = listBatches(h.root);
+        const add = await orchestrateFromCli(["--add", id, "2", "1", "x", "9"], client);
+        assert.deepEqual(add.added, [2]);
+        assert.deepEqual(add.skipped.map((x) => [x.issue, x.reason]).sort(), [[1, "already in batch"], [9, "closed"], ["x", "not an integer"]]);
+        await until(() => h.launched().includes(2));
+        const resumed = orchestrateFromCli(["--resume", id, "4"], client);
+        await until(() => h.launched().includes(4));
+        assert.deepEqual(listBatches(h.root), [id], "no second batch");
+        writeFileSync(h.release, "");
+        const [done] = await Promise.all([first, resumed]);
+        assert.deepEqual(done.rows.map((r) => [r.issue, r.outcome]), [[1, "merged"], [2, "merged"], [4, "merged"]]);
+        // Finished and no longer hosted: the add is persisted and the next --resume runs it instead of replaying the report.
+        const later = await orchestrateFromCli(["--add", id, "6"], client);
+        assert.deepEqual(later.added, [6]);
+        const again = await orchestrateFromCli(["--resume", id], client);
+        assert.deepEqual(again.rows.map((r) => [r.issue, r.outcome]), [[1, "merged"], [2, "merged"], [4, "merged"], [6, "merged"]]);
+        return done;
+      }));
+      assert.equal(res.rows.length, 3);
+      assert.deepEqual(h.launched(), [1, 2, 4, 6], "each issue launched once");
+    } finally { h.cleanup(); }
+  });
+
+  it("#4376: --cancel stops one batch (its lane torn down, the rest held, report written); the other batch and the daemon run on", async () => {
+    const h = host();
+    try {
+      const d = await h.daemon();
+      await withRoot(h, () => capture(async () => {
+        const a = orchestrateFromCli(["1", "2", "--parallel", "1", "--repo", "o/r", "--no-prefilter"], h.client);
+        await until(() => h.launched().length === 1 && h.lanePids().length === 1);
+        const [idA] = listBatches(h.root);
+        const b = orchestrateFromCli(["5", "--parallel", "1", "--repo", "o/r", "--no-prefilter"], h.client);
+        await until(() => h.launched().includes(5) && h.lanePids().length === 2);
+        const idB = listBatches(h.root).find((x) => x !== idA);
+        const res = await orchestrateFromCli(["--cancel", idA], h.client);
+        assert.deepEqual(res, { ok: true, batch: idA, cancelled: true });
+        const doneA = await a;
+        assert.deepEqual(doneA.rows.map((r) => [r.issue, r.outcome, r.detail]), [[1, "held", "cancelled by operator"], [2, "held", "cancelled by operator"]]);
+        assert.ok(openBatch(h.root, idA).readReport(), "the cancelled batch wrote its report");
+        assert.deepEqual(h.launched(), [1, 5], "#2 never launched");
+        const st = await request(await connectDaemon({ dir: h.sched, spawnDaemon: null }), { op: "status" });
+        assert.equal(st.pid, d.pid, "the daemon kept running");
+        assert.deepEqual(st.batches.map((x) => x.id), [idB]);
+        writeFileSync(h.release, "");
+        const doneB = await b;
+        assert.deepEqual(doneB.rows.map((r) => [r.issue, r.outcome]), [[5, "merged"]]);
+        const again = await orchestrateFromCli(["--cancel", idA], h.client);
+        assert.equal(again.cancelled, false, "a finished batch is left alone");
+        await assert.rejects(orchestrateFromCli(["--cancel", "nope"], h.client), /no batch nope/);
+      }));
+    } finally { h.cleanup(); }
+  });
+
+  it("#4481: a batch cancelled through the daemon is not resumed by a schedd restart", async () => {
+    const h = host();
+    try {
+      const statusIds = async () => (await request(await connectDaemon({ dir: h.sched, spawnDaemon: null }), { op: "status" })).batches.map((x) => x.id);
+      const kill = async (d) => { const gone = new Promise((r) => d.on("exit", r)); d.kill("SIGKILL"); await gone; };
+      let d = await h.daemon();
+      await withRoot(h, () => capture(async () => {
+        const a = orchestrateFromCli(["1", "2", "--parallel", "1", "--repo", "o/r", "--no-prefilter"], h.client);
+        await until(() => h.launched().length === 1 && h.lanePids().length === 1);
+        const [idA] = listBatches(h.root);
+        assert.equal((await orchestrateFromCli(["--cancel", idA], h.client)).cancelled, true);
+        await a;
+        await kill(d);
+        d = await h.daemon();
+        await new Promise((r) => setTimeout(r, 300));
+        assert.deepEqual(await statusIds(), [], "the restarted daemon hosts no cancelled batch");
+        assert.deepEqual(h.launched(), [1]);
+      }));
+    } finally { h.cleanup(); }
+  });
+
   it("single instance: a live daemon keeps its lock; a dead owner's lock and socket are taken over", async () => {
     const h = host();
     try {
@@ -171,6 +255,89 @@ await orchestrateFromCli(["1", "2", "--parallel", "2", "--repo", "o/r", "--no-pr
     } finally { h.cleanup(); }
   });
 
+  it("#4454: close() stops every hosted batch loop before releasing the lock; no batch admits a lane after close()", async () => {
+    const dir = tmpDir("schedd-stop-"), root = join(dir, "batches"), lock = scheddPaths(dir).lock;
+    const started = { a: [], b: [] }, stoppedWithLock = {};
+    let releaseLane;
+    const lane = new Promise((r) => { releaseLane = r; });
+    // An unref'd cancellable sleep: a base without the stop cannot hang the test process on the 30-min requeue delay.
+    const sleep = (ms, sig) => new Promise((r) => { const t = setTimeout(r, ms); t.unref(); sig?.addEventListener("abort", () => { clearTimeout(t); r(); }, { once: true }); });
+    const runBatch = async ({ argv, sink, signal }) => {
+      const id = argv[0];
+      sink.batch({ id, dir: join(root, id) });
+      try {
+        return await orchestrate({ issues: id === "a" ? [1, 2] : [9], parallel: 1, readBody: async () => "", signal, sleep,
+          runOne: async (n) => {
+            started[id].push(n);
+            if (n === 1) { await lane; return { terminalReason: "merged" }; } // a detached lane, still running at shutdown
+            if (n === 9) return { terminalReason: "deferred", detail: `leased by x until ${new Date(Date.now() + 3600e3).toISOString()}` };
+            return { terminalReason: "merged" };
+          } });
+      } finally { stoppedWithLock[id] = existsSync(lock); }
+    };
+    const d = await startDaemon({ dir, root, runBatch, log: () => {}, resumeOnStart: false });
+    const submit = async (id) => request(await connectDaemon({ dir, spawnDaemon: null }), { op: "submit", argv: [id], cwd: dir, env: {} }).catch((e) => e);
+    const clients = [submit("a"), submit("b")]; // each resolves (or rejects) once its connection ends
+    await until(() => started.a.length === 1 && started.b.length === 1);
+    await new Promise((r) => setTimeout(r, 100)); // b is asleep on its requeue delay
+    const t0 = Date.now();
+    await d.close();
+    assert.ok(Date.now() - t0 < 3000, `close() took ${Date.now() - t0} ms`);
+    assert.deepEqual(stoppedWithLock, { a: true, b: true }, "both batch loops stopped while the lock was still held");
+    assert.equal(existsSync(lock), false, "lock released after the loops stopped");
+    assert.equal(existsSync(scheddPaths(dir).sock), false);
+    releaseLane();
+    await new Promise((r) => setTimeout(r, 200));
+    assert.deepEqual(started, { a: [1], b: [9] }, "no hosted batch admits a lane after close()");
+    await Promise.all(clients);
+  });
+
+  it("#4454: close() waits at most stopMs for a batch that ignores the stop, then releases the lock", async () => {
+    const dir = tmpDir("schedd-bound-");
+    const d = await startDaemon({ dir, root: join(dir, "batches"), log: () => {}, resumeOnStart: false, stopMs: 200,
+      runBatch: ({ sink }) => { sink.batch({ id: "x", dir }); return new Promise(() => {}); } });
+    request(await connectDaemon({ dir, spawnDaemon: null }), { op: "submit", argv: ["x"], cwd: dir, env: {} }).catch(() => {});
+    await new Promise((r) => setTimeout(r, 50));
+    const t0 = Date.now();
+    await d.close();
+    const took = Date.now() - t0;
+    assert.ok(took >= 150 && took < 2000, `close() took ${took} ms`);
+    assert.equal(existsSync(scheddPaths(dir).lock), false);
+  });
+
+  it("#4454: kill -TERM stops both batches and exits 143 within the bound; lanes keep running; the next daemon resumes and adopts them", async () => {
+    const h = host();
+    try {
+      const d1 = await h.daemon();
+      await withRoot(h, () => capture(async () => {
+        const a = orchestrateFromCli(["1", "2", "--parallel", "1", "--repo", "o/r", "--no-prefilter"], h.client).then(() => null, (e) => e);
+        await until(() => h.launched().length === 1 && h.lanePids().length === 1);
+        const [idA] = listBatches(h.root);
+        const b = orchestrateFromCli(["5", "--parallel", "1", "--repo", "o/r", "--no-prefilter"], h.client).then(() => null, (e) => e);
+        await until(() => h.launched().includes(5) && h.lanePids().length === 2);
+        const idB = listBatches(h.root).find((x) => x !== idA);
+        const lanes = h.lanePids();
+        const exit = new Promise((r) => d1.on("exit", (code) => r(code)));
+        const t0 = Date.now();
+        d1.kill("SIGTERM");
+        assert.equal(await exit, 143);
+        assert.ok(Date.now() - t0 < 12000, "exits within the bound");
+        for (const pid of lanes) assert.equal(isLaneAlive(pid, null), true, "lanes keep running");
+        assert.equal(existsSync(scheddPaths(h.sched).lock), false);
+        assert.equal(openBatch(h.root, idA).readReport(), null, "a stopped batch writes no report");
+        assert.equal(openBatch(h.root, idB).readReport(), null);
+        assert.match(String((await a)?.message), /--resume/);
+        await b;
+        await h.daemon(); // resumes both batches
+        const ra = orchestrateFromCli(["--resume", idA], h.client), rb = orchestrateFromCli(["--resume", idB], h.client);
+        setTimeout(() => writeFileSync(h.release, ""), 200);
+        assert.deepEqual((await ra).rows.map((r) => [r.issue, r.outcome]), [[1, "merged"], [2, "merged"]]);
+        assert.deepEqual((await rb).rows.map((r) => [r.issue, r.outcome]), [[5, "merged"]]);
+        assert.deepEqual(h.launched(), [1, 2, 5], "adopted, not relaunched");
+      }));
+    } finally { h.cleanup(); }
+  });
+
   it("lane env: allowlisted keys come from the client only, the rest from the daemon", () => {
     const kept = batchEnv({ PATH: "/c", CLAUDE_CONFIG_DIR: "/acct-b", SECRET_X: "no", FORGEDOCK_SCHED_DIR: "/s" });
     assert.deepEqual(kept, { PATH: "/c", CLAUDE_CONFIG_DIR: "/acct-b", FORGEDOCK_SCHED_DIR: "/s" });

package/bin/lean/selfreview.mjs

@@ -0,0 +1,37 @@
+// SPDX-FileCopyrightText: Copyright (c) RapierCraft Studios
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * Builder self-review (#4374): the builder answers the shared `REVIEW_RUBRIC` (prompts.mjs) in result.json
+ * `self_review: [{question, answer, evidence}]` inside its build session. The engine only reads and logs it: a missing
+ * self-review is SELF_REVIEW_MISSING, and the first reviewer judgement is compared with it (SELF_REVIEW_AGREED /
+ * SELF_REVIEW_DISAGREED). Never a failure, never a runner call. Pure: no I/O.
+ */
+
+const text = (v) => (v === null || v === undefined ? "" : String(v)).trim();
+
+/**
+ * The self-review of a result: `present` with its items and the questions not answered yes, `missing` when a fixed result
+ * has no non-empty `self_review` array, `invalid` when an entry lacks a question or an answer, or null for a result
+ * that is not `fixed` (nothing to self-review).
+ */
+export function readSelfReview(result) {
+  if (!result || typeof result !== "object" || result.status !== "fixed") return null;
+  const raw = result.self_review;
+  if (!Array.isArray(raw) || !raw.length) return { state: "missing", items: [], no: [] };
+  const items = raw.map((x) => ({ question: text(x?.question), answer: text(x?.answer), evidence: text(x?.evidence) }));
+  if (items.some((x) => !x.question || !x.answer)) return { state: "invalid", items, no: [] };
+  return { state: "present", items, no: items.filter((x) => x.answer.toLowerCase() !== "yes").map((x) => x.question) };
+}
+
+/**
+ * Compare a present self-review with a reviewer decision (`decide()` state). Null when either side has no judgement
+ * (self-review not present, reviewer reply incomplete, unparseable or skipped). Agreement: all yes and the reviewer
+ * conforms, or any no and the reviewer finds it nonconforming.
+ */
+export function compareSelfReview(self, decision) {
+  if (self?.state !== "present") return null;
+  const reviewer = decision?.state;
+  if (reviewer !== "conforms" && reviewer !== "nonconforming") return null;
+  const allYes = self.no.length === 0;
+  return { agreed: allYes === (reviewer === "conforms"), reviewer, self_no: self.no };
+}

package/bin/lean/selfreview.test.mjs

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: Copyright (c) RapierCraft Studios
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readSelfReview, compareSelfReview } from "./selfreview.mjs";
+
+const item = (question, answer = "yes", evidence = "src/a.py:3") => ({ question, answer, evidence });
+
+describe("readSelfReview (#4374)", () => {
+  it("only a fixed result is self-reviewed", () => {
+    for (const r of [null, undefined, "x", { status: "blocked" }, { status: "invalid", self_review: [item("1")] }]) assert.equal(readSelfReview(r), null);
+  });
+
+  it("a fixed result without a non-empty self_review array is missing", () => {
+    for (const self_review of [undefined, null, [], "yes", {}]) assert.deepEqual(readSelfReview({ status: "fixed", self_review }), { state: "missing", items: [], no: [] });
+  });
+
+  it("an entry without a question or an answer is invalid", () => {
+    assert.equal(readSelfReview({ status: "fixed", self_review: [item("1"), { question: "2" }] }).state, "invalid");
+    assert.equal(readSelfReview({ status: "fixed", self_review: [null] }).state, "invalid");
+  });
+
+  it("present: items normalized, the questions not answered yes listed", () => {
+    const sr = readSelfReview({ status: "fixed", self_review: [item(" 1 ", "YES"), item("2", "no", 7), item(3, "partly", null)] });
+    assert.equal(sr.state, "present");
+    assert.deepEqual(sr.items, [item("1", "YES"), item("2", "no", "7"), { question: "3", answer: "partly", evidence: "" }]);
+    assert.deepEqual(sr.no, ["2", "3"]);
+  });
+});
+
+describe("compareSelfReview (#4374)", () => {
+  const yes = readSelfReview({ status: "fixed", self_review: [item("1"), item("2")] });
+  const no = readSelfReview({ status: "fixed", self_review: [item("1"), item("2", "no")] });
+
+  it("all yes agrees with conforms and disagrees with nonconforming", () => {
+    assert.deepEqual(compareSelfReview(yes, { state: "conforms" }), { agreed: true, reviewer: "conforms", self_no: [] });
+    assert.deepEqual(compareSelfReview(yes, { state: "nonconforming" }), { agreed: false, reviewer: "nonconforming", self_no: [] });
+  });
+
+  it("a no agrees with nonconforming and disagrees with conforms", () => {
+    assert.deepEqual(compareSelfReview(no, { state: "nonconforming" }), { agreed: true, reviewer: "nonconforming", self_no: ["2"] });
+    assert.deepEqual(compareSelfReview(no, { state: "conforms" }), { agreed: false, reviewer: "conforms", self_no: ["2"] });
+  });
+
+  it("no comparison without a judgement on either side", () => {
+    for (const s of ["review.incomplete", "review.unparseable", "review.inconsistent", "environment", undefined]) assert.equal(compareSelfReview(yes, { state: s }), null, String(s));
+    assert.equal(compareSelfReview(null, { state: "conforms" }), null);
+    assert.equal(compareSelfReview({ state: "missing", items: [], no: [] }, { state: "conforms" }), null);
+    assert.equal(compareSelfReview(yes, null), null);
+  });
+});

package/bin/lean/seqlease.mjs

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: Copyright (c) RapierCraft Studios
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * Host sequence lease (#4386): one lane at a time per (repo, lane branch, sequence dir) in the window from the
+ * merge-gate renumber of its numbered files to its merge, so parallel lanes stop overtaking each other's numbers.
+ * Each key is a one-slot `heavy.mjs` semaphore in its own registry dir (`schedDir()/seq-lease/<key>/heavy.json`):
+ * file-locked, FIFO, dead holders dropped by pid. The heavy-step registry and its env caps are never touched.
+ * Fail-open: a wait over `maxWaitS` (or an unreadable registry) proceeds without the lease; CI and base-sync stay the gate.
+ */
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { acquireHeavy, openHeavy } from "./heavy.mjs";
+import { schedDir } from "./sched.mjs";
+
+/** The lease key of one sequence dir of one lane branch of one repo. */
+export const sequenceLeaseKey = (repo, lane, dir) => createHash("sha1").update(`${repo}\0${lane}\0${dir}`).digest("hex").slice(0, 16);
+
+const NO_MEM = Object.freeze({ cores: () => 2, memAvailableMb: () => null });
+
+/**
+ * `acquire({repo, lane, dirs, issue, maxWaitS})` takes every dir's lease in sorted order (no lock-order deadlock).
+ * @returns {{acquire: (e:object) => Promise<{waitMs:number, timedOut:boolean, release:Function}>}}
+ */
+export function makeSequenceLeaseIo({ dir = join(schedDir(), "seq-lease"), open = openHeavy, acquire = acquireHeavy, pollMs } = {}) {
+  return {
+    async acquire({ repo, lane, dirs = [], issue = null, maxWaitS = 1800 } = {}) {
+      const held = [];
+      let waitMs = 0, timedOut = false;
+      for (const d of [...new Set(dirs)].sort()) {
+        const h = open(join(dir, sequenceLeaseKey(repo, lane, d)), { cfg: { max: 1, max_wait_s: maxWaitS }, env: {}, host: NO_MEM });
+        const g = await acquire(h, { issue, phase: "sequence" }, ...(pollMs ? [{ pollMs }] : []));
+        waitMs += g.waitMs ?? 0;
+        if (g.timedOut) timedOut = true;
+        held.push(g);
+      }
+      let released = false;
+      return { waitMs, timedOut, release: () => { if (released) return; released = true; for (const g of held.reverse()) { try { g.release(); } catch { /* fail-open */ } } } };
+    },
+  };
+}

package/bin/lean/seqlease.test.mjs

@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: Copyright (c) RapierCraft Studios
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Host sequence lease (#4386): one numbered-file lane per (repo, lane, dir) in the renumber→CI→merge window.
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpDir } from "../tests/_tmp.mjs";
+import { makeSequenceLeaseIo, sequenceLeaseKey } from "./seqlease.mjs";
+import { sequenceCollisions, journalProblems, renumberLane } from "./sequence.mjs";
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const lease = () => makeSequenceLeaseIo({ dir: tmpDir("seqlease-"), pollMs: 20 });
+
+describe("sequence lease (#4386)", () => {
+  it("a second acquire on the same (repo, lane, dir) waits for the release; other dirs, lanes and repos do not; release is idempotent", async () => {
+    const io = lease(), order = [];
+    const a = await io.acquire({ repo: "o/r", lane: "staging", dirs: ["db"], maxWaitS: 30 });
+    const other = await io.acquire({ repo: "o/r", lane: "staging", dirs: ["docs/adr"], maxWaitS: 30 });
+    const otherLane = await io.acquire({ repo: "o/r", lane: "milestone/x", dirs: ["db"], maxWaitS: 30 });
+    assert.equal(other.timedOut, false);
+    assert.equal(otherLane.timedOut, false);
+    const b = io.acquire({ repo: "o/r", lane: "staging", dirs: ["db"], maxWaitS: 30 }).then((g) => { order.push("b"); return g; });
+    await sleep(150);
+    order.push("a-release");
+    a.release(); a.release();
+    const gb = await b;
+    assert.deepEqual(order, ["a-release", "b"]);
+    assert.ok(gb.waitMs >= 100);
+    gb.release(); other.release(); otherLane.release();
+    assert.notEqual(sequenceLeaseKey("o/r", "staging", "db"), sequenceLeaseKey("o/r", "staging", "db2"));
+  });
+
+  it("a wait over maxWaitS proceeds without the lease (fail-open)", async () => {
+    const io = lease();
+    const a = await io.acquire({ repo: "o/r", lane: "staging", dirs: ["db"], maxWaitS: 30 });
+    const b = await io.acquire({ repo: "o/r", lane: "staging", dirs: ["db"], maxWaitS: 0.1 });
+    assert.equal(b.timedOut, true);
+    b.release(); a.release();
+  });
+});
+
+const env = { ...process.env, GIT_AUTHOR_NAME: "t", GIT_AUTHOR_EMAIL: "t@t", GIT_COMMITTER_NAME: "t", GIT_COMMITTER_EMAIL: "t@t" };
+const sh = (cwd, ...a) => execFileSync("git", a, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], env });
+const gitIn = (cwd) => async (a) => sh(cwd, ...a);
+const put = (root, files) => { for (const [p, t] of Object.entries(files)) { mkdirSync(dirname(join(root, p)), { recursive: true }); writeFileSync(join(root, p), t); } };
+const commit = (d, m) => { sh(d, "add", "-A"); sh(d, "commit", "-qm", m); };
+const journal = (...tags) => `${JSON.stringify({ version: "7", entries: tags.map((tag, idx) => ({ idx, tag, when: 1000 + idx })) }, null, 2)}\n`;
+const snap = (id, prevId) => `${JSON.stringify({ version: "7", id, prevId, tables: { t: 1 } }, null, 2)}\n`;
+
+describe("two lanes adding migrations to the same lane branch (#4386) [integration]", () => {
+  it("the second renumbers at the merge gate under the lease and merges; neither ends base.conflict", async () => {
+    const root = tmpDir("seqlanes-"), origin = join(root, "origin.git"), seed = join(root, "seed");
+    sh(root, "init", "-q", "--bare", "-b", "staging", origin);
+    sh(root, "clone", "-q", origin, seed);
+    sh(seed, "checkout", "-qb", "staging");
+    put(seed, { "db/0048_init.sql": "CREATE TABLE t (id int);\n", "db/meta/_journal.json": journal("0048_init"), "db/meta/0048_snapshot.json": snap("s48", "s47") });
+    commit(seed, "init");
+    sh(seed, "push", "-q", "origin", "staging");
+    const lanes = ["a", "b"].map((n) => {
+      const d = join(root, `lane-${n}`);
+      sh(root, "clone", "-q", "-b", "staging", origin, d);
+      sh(d, "checkout", "-qb", `feat/${n}`);
+      put(d, { [`db/0049_${n}.sql`]: `INSERT INTO t VALUES ('${n}');\n`, "db/meta/_journal.json": journal("0048_init", `0049_${n}`), "db/meta/0049_snapshot.json": snap(`lane-${n}`, "s48") });
+      commit(d, `lane ${n}`);
+      return d;
+    });
+    const io = lease(), outcomes = [];
+    let inWindow = 0, maxInWindow = 0;
+    /** The merge gate of one lane: lease, re-fetch, late renumber when the number is taken, "CI", merge, release. */
+    const gate = async (d) => {
+      const l = await io.acquire({ repo: "o/r", lane: "staging", dirs: ["db"], maxWaitS: 60 });
+      inWindow++; maxInWindow = Math.max(maxInWindow, inWindow);
+      try {
+        sh(d, "fetch", "-q", "origin", "staging");
+        const base = "origin/staging";
+        const c = await sequenceCollisions({ git: gitIn(d), base });
+        let how = "no collision";
+        if (c.length) {
+          const r = await renumberLane({ git: gitIn(d), base, cwd: d });
+          assert.ok(r.ok, r.unsupported);
+          how = `renumbered ${r.moves.map((m) => m.to).join(", ")}`;
+        }
+        await sleep(100); // required checks
+        sh(d, "push", "-q", "origin", "HEAD:staging"); // the merge: rejected if the base moved meanwhile
+        outcomes.push({ d, how, outcome: "merged" });
+      } catch (e) { outcomes.push({ d, outcome: "base.conflict", error: String(e?.message ?? e) }); }
+      finally { inWindow--; l.release(); }
+    };
+    await Promise.all(lanes.map(gate));
+    assert.deepEqual(outcomes.map((o) => o.outcome), ["merged", "merged"], JSON.stringify(outcomes));
+    assert.equal(maxInWindow, 1, "one numbered-file PR in the window at a time");
+    assert.equal(outcomes[0].how, "no collision");
+    assert.match(outcomes[1].how, /renumbered db\/0050_[ab]\.sql/);
+    sh(seed, "pull", "-q", "origin", "staging");
+    const tags = JSON.parse(sh(seed, "show", "HEAD:db/meta/_journal.json")).entries.map((e) => e.tag);
+    assert.deepEqual(tags.map((t) => t.slice(0, 4)), ["0048", "0049", "0050"]);
+    assert.deepEqual(await journalProblems({ git: gitIn(seed), dirs: ["db"] }), []);
+  });
+});