forgedock 1.31.0 → 1.32.0

package/bin/lean/prefilter.test.mjs

@@ -2,10 +2,14 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { prefilterIssue, flakyReason, makePrefilter, postDeployGate, postDeployOnly, deferredFrom, formatParkedLine, lazyDefaultBranch, ownLogins, resolveOwnLogins, formatPrefilterSummary, claimsFix, ciFailureRun, namedPaths, isTrustedIssueComment, DEFAULT_PREFILTER_MODEL } from "./prefilter.mjs";
+import { prefilterIssue, flakyReason, makePrefilter, postDeployGate, postDeployOnly, deferredFrom, formatParkedLine, lazyDefaultBranch, ownLogins, resolveOwnLogins, formatPrefilterSummary, claimsFix, ciFailureRun, namedPaths, isTrustedIssueComment, DEFAULT_PREFILTER_MODEL, parseMinAge, itemWindowsMs, landedAt } from "./prefilter.mjs";
+import { writeFileSync } from "node:fs";
+import { tmpDir } from "../tests/_tmp.mjs";
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
 import { parsePrefilterVerdict, prefilterPrompt } from "./prompts.mjs";
 import { orchestrate, formatTable, formatOutcomeLists } from "./orchestrate.mjs";
-import { triageFromCli } from "../engine-cli.mjs";
+import { triageFromCli, readPostDeployMinAge } from "../engine-cli.mjs";
 
 const fence = (o) => "```json\n" + JSON.stringify(o) + "\n```";
 
@@ -477,6 +481,109 @@ describe("post-deploy precondition gate (#4389)", () => {
   });
 });
 
+describe("post_deploy.min_age soak window (#4425)", () => {
+  const MERGE = "a".repeat(40), PROMO = "b".repeat(40), MAIN = "c".repeat(40);
+  const H = 3600, LANDED = 1_800_000_000; // unix seconds of the promotion merge
+  const item = (id, why) => `- [ ] \`${id}: a health row exists\` — post-deploy: ${why}`;
+  const followup = (items) => `## Acceptance Criteria\n\n${items.join("\n")}\n\n<!-- FORGE:DEFERRED_FROM: #40 -->\n`;
+  const parentPr = [{ number: 90, title: "fix(x): health row (#40)", body: "", mergeCommit: { oid: MERGE } }];
+  // the parent fix reached main through promotion merge PROMO (first parent MAIN) at LANDED
+  const soakWorld = (o = {}) => {
+    const w = world({ mergedPrs: parentPr, ancestry: { [MERGE]: 0 }, ...o });
+    const git = w.io.git;
+    w.io.git = async (a, opts) => {
+      if (a[0] === "log" && a[1] === "--first-parent") { w.gitCalls.push(a); return o.walk ?? `${"d".repeat(40)} ${PROMO} ${LANDED + 9 * H}\n${PROMO} ${MAIN} ${MERGE} ${LANDED}\n${MAIN} ${"e".repeat(40)} ${LANDED - H}\n`; }
+      if (a[0] === "rev-list") { w.gitCalls.push(a); return o.below ?? `${"d".repeat(40)}\n${PROMO}\n`; }
+      if (a[0] === "log" && a[1] === "-1") { w.gitCalls.push(a); return String(LANDED - 5 * H); }
+      return git(a, opts);
+    };
+    return w;
+  };
+  const gate = (w, body, extra = {}) => postDeployGate({ iss: { number: 41, body }, repo: "o/r", lane: "staging", defaultBranch: "main", cwd: "/repo", io: w.io, ...extra });
+
+  it("parses min_age and the windows each post-deploy item's why states (largest wins, none -> null)", () => {
+    assert.equal(parseMinAge("24h"), 24 * H * 1000); assert.equal(parseMinAge("7d"), 7 * 24 * H * 1000); assert.equal(parseMinAge("2w"), 14 * 24 * H * 1000);
+    assert.equal(parseMinAge("30m"), 30 * 60e3); assert.equal(parseMinAge("0"), 0); assert.equal(parseMinAge(90), 90 * 60e3);
+    assert.equal(parseMinAge("soon"), null); assert.equal(parseMinAge(null), null);
+    assert.deepEqual(itemWindowsMs(followup([item("R1", "after 24h of traffic, then 7 days of retention"), item("R2", "only in prod")])), [7 * 24 * H * 1000, null]);
+  });
+
+  it("landedAt: the promotion merge time, or the SHA's own time when it is on the mainline", async () => {
+    const w = soakWorld();
+    assert.equal(await landedAt({ sha: MERGE, def: "main", io: w.io, cwd: "/repo" }), LANDED);
+    assert.deepEqual(w.gitCalls.slice(0, 2), [["rev-list", "--ancestry-path", `${MERGE}..origin/main`], ["log", "--first-parent", "--format=%H %P %ct", `${MERGE}..origin/main`]]);
+    const own = soakWorld({ walk: `${PROMO} ${MERGE} ${LANDED}\n`, below: `${PROMO}\n` });
+    assert.equal(await landedAt({ sha: MERGE, def: "main", io: own.io, cwd: "/repo" }), LANDED - 5 * H);
+    const tip = soakWorld({ walk: "", below: "" });
+    assert.equal(await landedAt({ sha: MERGE, def: "main", io: tip.io, cwd: "/repo" }), LANDED - 5 * H);
+  });
+
+  it("landedAt on a real repo: the promotion merge that brought a staging fix in through its second parent", async () => {
+    const d = tmpDir("landed-");
+    const run = (args, t) => execFileSync("git", args, { cwd: d, encoding: "utf8", env: { ...process.env, GIT_AUTHOR_DATE: `@${t} +0000`, GIT_COMMITTER_DATE: `@${t} +0000`,
+      GIT_AUTHOR_NAME: "t", GIT_AUTHOR_EMAIL: "t@t", GIT_COMMITTER_NAME: "t", GIT_COMMITTER_EMAIL: "t@t", GIT_CONFIG_GLOBAL: "/dev/null", GIT_CONFIG_NOSYSTEM: "1" } }).trim();
+    run(["init", "-q", "-b", "main"], 1);
+    run(["commit", "-q", "--allow-empty", "-m", "base"], LANDED - 10 * H);
+    run(["checkout", "-q", "-b", "staging"], 1);
+    run(["commit", "-q", "--allow-empty", "-m", "fix"], LANDED - 8 * H);
+    const fix = run(["rev-parse", "HEAD"], 1);
+    run(["checkout", "-q", "main"], 1);
+    run(["commit", "-q", "--allow-empty", "-m", "hotfix on main"], LANDED - 2 * H);
+    run(["merge", "-q", "--no-ff", "-m", "promote", "staging"], LANDED);
+    run(["commit", "-q", "--allow-empty", "-m", "later"], LANDED + 5 * H);
+    run(["update-ref", "refs/remotes/origin/main", "HEAD"], 1);
+    const io = { git: async (a, o) => run(a, 1) + "\n" };
+    assert.equal(await landedAt({ sha: fix, def: "main", io, cwd: d }), LANDED);
+    assert.equal(await landedAt({ sha: fix.slice(0, 12), def: "main", io, cwd: d }), LANDED);
+    assert.equal(await landedAt({ sha: run(["rev-parse", "HEAD~1^1"], 1), def: "main", io, cwd: d }), LANDED - 2 * H); // on the mainline itself
+    assert.equal(await landedAt({ sha: "f".repeat(40), def: "main", io, cwd: d }), null);
+  });
+
+  it("parks awaiting-min-age until max(item window ?? min_age) after landing, then is ready", async () => {
+    const body = followup([item("R1", "wait 7d of production data"), item("R2", "only in prod")]);
+    const g = await gate(soakWorld(), body, { minAge: parseMinAge("24h"), now: (LANDED + 48 * H) * 1000 });
+    assert.equal(g.state, "awaiting-min-age");
+    assert.equal(g.eligibleAt, new Date((LANDED + 7 * 24 * H) * 1000).toISOString());
+    assert.match(g.detail, /^fix of #40 on main since .*; min age 7d until /);
+    // no stated window: the min_age floor applies
+    const short = followup([item("R2", "only in prod")]);
+    assert.equal((await gate(soakWorld(), short, { minAge: parseMinAge("24h"), now: (LANDED + 23 * H) * 1000 })).state, "awaiting-min-age");
+    assert.equal((await gate(soakWorld(), short, { minAge: parseMinAge("24h"), now: (LANDED + 25 * H) * 1000 })).state, "ready");
+    assert.equal((await gate(soakWorld(), body, { minAge: 0, now: (LANDED + 8 * 24 * H) * 1000 })).state, "ready");
+  });
+
+  it("unset min_age changes nothing (no landing-time git calls); an unknown landing time fails open", async () => {
+    const w = soakWorld();
+    assert.equal((await gate(w, followup([item("R1", "wait 7d")]))).state, "ready");
+    assert.ok(!w.gitCalls.some((a) => a[0] === "log" || a[0] === "rev-list"));
+    const broken = soakWorld();
+    const git = broken.io.git;
+    broken.io.git = async (a, o) => { if (a[0] === "rev-list") throw Object.assign(new Error("bad"), { code: 128 }); return git(a, o); };
+    const g = await gate(broken, followup([item("R1", "wait 7d")]), { minAge: 0 });
+    assert.equal(g.state, "unresolved"); assert.match(g.detail, /landing time of aaaaaaaaaaaa on main unknown/);
+  });
+
+  it("prefilterIssue parks it with the awaiting-promotion label, one comment, and an 'awaiting min age:' report line", async () => {
+    const w = soakWorld({ issues: { 41: { body: followup([item("R1", "wait 7d")]) } } });
+    w.io.now = () => (LANDED + H) * 1000;
+    const r = await pf(w, 41, { defaultBranch: "main", minAge: parseMinAge("24h") });
+    assert.equal(r.parked, true); assert.equal(r.kind, "awaiting-min-age"); assert.equal(r.cost_usd, 0);
+    assert.deepEqual(w.edits, [[41, "--add-label", "awaiting-promotion"]]);
+    assert.equal(w.comments.length, 1); assert.match(w.comments[0][1], /Parked: awaiting its post-deploy soak window/);
+    assert.equal(formatParkedLine([{ issue: 41, prefilter: r }, { issue: 42, prefilter: { parked: true, kind: "awaiting-promotion", lane: "staging", default: "main" } }]),
+      "awaiting promotion: #42 (fixes on staging, not on main)\nawaiting min age: #41 (fix on main, soak window not elapsed)");
+  });
+
+  it("readPostDeployMinAge reads forge.yaml post_deploy.min_age; absent or invalid -> null", async () => {
+    const d = tmpDir("minage-");
+    assert.equal(await readPostDeployMinAge(d), null);
+    writeFileSync(join(d, "forge.yaml"), "post_deploy:\n  min_age: \"24h\"\n");
+    assert.equal(await readPostDeployMinAge(d), 24 * H * 1000);
+    writeFileSync(join(d, "forge.yaml"), "post_deploy:\n  min_age: later\n");
+    assert.equal(await readPostDeployMinAge(d), null);
+  });
+});
+
 describe("#4467: isTrustedIssueComment", () => {
   it("trusts the App in gh issue view and REST shapes and trusted associations; not other contributors", () => {
     assert.equal(isTrustedIssueComment({ author: { login: "rapiercraft-forgedock" }, authorAssociation: "CONTRIBUTOR" }), true);

package/bin/lean/prompts.mjs

@@ -24,6 +24,9 @@ export const FORGEDOCK_CLI = fileURLToPath(new URL("../forgedock.mjs", import.me
 const HOST_RULES = `Host rules (many lanes share this machine): run only targeted tests (specific files or -k filters), never the full suite. Never create extra checkouts, copies or base clones of the repo; compare with git show or git diff origin/<base>. Never install browsers. Keep scratch files under $TMPDIR. Cap verification workers at $FORGE_HOST_PARALLELISM when set: turbo --concurrency, vitest/jest --maxWorkers, playwright --workers, node --test --test-concurrency (eslint via turbo). For any typecheck, lint or test you run, first run \`node ${CHECKS_CLI} --base origin/<base>\` after your edits and run the scoped commands it prints instead of the full tsc/eslint/test scripts (it widens itself when impact is unknown: lockfile, tsconfig, CI config); once they pass, rerun it with --publish to share the incremental caches. Lint changed packages only, never dependents (turbo ...[base], nx affected). node_modules/.venv may be hardlinked read-only from a shared cache: after changing a lockfile, or when an install fails with EACCES, delete that dir first (rm -rf is safe), then install; never chmod or edit files inside it.
 Quiet output (tool results are re-read every later turn): run tests quietly (-q or a dot/summary reporter); on failure read \`tail -40\` plus the failing test ids (grep FAILED / not ok / FAIL), never the whole log. Send output over 8 KB to a $TMPDIR file; tail or grep it. Issue independent read-only calls (reads, greps, git log/blame, gh) in the same turn or one shell call. Read each file's ranges once (sed -n a,bp or Read offset/limit, never a whole large file) and keep notes; don't re-read it.`;
 
+/** #4450: the host-rules block of the builder prompts (toolchain, sparse and repo-facts lines included), reused by the light-lane prompt. */
+export const hostRules = ({ toolchain = null, sparse = null, facts = null } = {}) => `${HOST_RULES}${toolchainRule(toolchain)}${sparseRule(sparse)}${factsRule(facts)}`;
+
 /** Verify-by-CI (#4167): in ci/hybrid mode the engine runs the repo's CI on GitHub runners; the host runs only light checks. */
 const LIGHT = "run only formatters and linters on the files you changed";
 const VERIFY_RUN = { ci: `${LIGHT} (no type-checks, test suites or test containers)`, hybrid: "run the targeted validate commands" };

package/bin/lean/sched.mjs

@@ -17,6 +17,9 @@
  * (`forgedock sched cap N`), else the caller's forge.yaml `orchestration.global_parallel`, else none. Fail-open: an
  * unreadable registry or a lock not taken within `lockWaitMs` grants (`fallback: true`), since a stuck registry would
  * stall every batch on the host.
+ * Per-issue lock (#4481), asked for per request with `exclusive: true` in the entry (not stored; the batch runner sets it):
+ * such a key is never granted while a live slot of another batch holds the same (non-null) repo and issue, so two batches that both include issue N (a resumed batch and a new one) never run two lanes for N at once;
+ * `tryAcquire` answers `{ok:false, conflict:<batch>}` and drops the key from the queue (it would hold a grant rank).
  */
 import { closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeSync } from "node:fs";
 import { homedir } from "node:os";
@@ -50,6 +53,14 @@ const posInt = (k) => (Number.isInteger(k) && k >= 1 ? k : null);
 const pause = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 const byRank = ([ka, a], [kb, b]) => (a.priority - b.priority) || (a.seq - b.seq) || (ka < kb ? -1 : ka > kb ? 1 : 0);
 const groupOf = (k, e) => e?.repo ?? e?.batch ?? k;
+/** #4481: the batch of another live slot running the same repo and issue as an `exclusive` `entry`, or null (no repo: never). */
+const holderOf = (s, key, entry) => {
+  if (entry?.exclusive !== true || !entry.repo || entry.issue == null) return null;
+  for (const [k, e] of Object.entries(s.slots)) {
+    if (k !== key && e?.repo === entry.repo && e?.issue === entry.issue && (e.batch ?? null) !== (entry.batch ?? null)) return e.batch ?? k;
+  }
+  return null;
+};
 
 /**
  * Queue entries `[key, entry]` in grant order: priority ascending, then a weighted fair share across repos within each
@@ -88,7 +99,7 @@ export function grantOrder(s) {
 
 /**
  * Handle on the registry. `pid` is this dispatcher; `alive(pid)` is the liveness probe (injected in tests).
- * @returns {{dir, tryAcquire, offer, withdraw, release, setLanePid, adoptSlot, cap, setCap, weights, setWeight, list}}
+ * @returns {{dir, tryAcquire, holder, offer, withdraw, release, setLanePid, adoptSlot, cap, setCap, weights, setWeight, list}}
  */
 export function openSched(dir = schedDir(), { now = () => Date.now(), pid = process.pid, alive = pidAlive, lockWaitMs = LOCK_WAIT_MS } = {}) {
   const file = join(dir, "registry.json"), lockFile = join(dir, "registry.lock");
@@ -167,6 +178,8 @@ export function openSched(dir = schedDir(), { now = () => Date.now(), pid = proc
       try {
         return mutate((s) => {
           if (s.slots[key]) return { ok: true };
+          const holder = holderOf(s, key, entry);
+          if (holder !== null) { delete s.queue[key]; return { ok: false, conflict: holder, reason: `#${entry.issue} has a live lane in batch ${holder}` }; }
           enqueue(s, key, entry);
           const cap = effCap(s, callerCap);
           if (cap !== null) {
@@ -182,6 +195,8 @@ export function openSched(dir = schedDir(), { now = () => Date.now(), pid = proc
         });
       } catch (e) { return { ok: true, fallback: true, reason: e?.message ?? String(e) }; }
     },
+    /** #4481: the other batch holding a live slot for `{repo, issue}` (not `batch`), or null; null on any error. */
+    holder: (entry = {}) => { try { return mutate((s) => holderOf(s, null, entry)); } catch { return null; } },
     /** Queue entries `[{key, batch, repo, issue, priority}]` (their FIFO position is kept on a re-offer). */
     offer: (entries) => { try { mutate((s) => { for (const e of entries) enqueue(s, e.key, e); }); } catch { /* fail-open */ } },
     withdraw: (keys) => { if (!keys.length) return; try { mutate((s) => { for (const k of keys) delete s.queue[k]; }); } catch { /* fail-open */ } },

package/bin/lean/sched.test.mjs

@@ -434,3 +434,51 @@ describe("longest-first admission (#4409)", () => {
     assert.equal(estCalls, 0);
   });
 });
+
+describe("#4481: one lane per repo and issue across batches", () => {
+  it("the registry refuses a second batch's key for a live repo+issue slot, names the batch and drops it from the queue", () => {
+    const { handle, live } = world();
+    const a = handle(201), b = handle(202);
+    assert.equal(a.tryAcquire("A#5", { batch: "A", repo: "o/r", issue: 5, exclusive: true }, 4).ok, true);
+    const r = b.tryAcquire("B#5", { batch: "B", repo: "o/r", issue: 5, exclusive: true }, 4);
+    assert.deepEqual([r.ok, r.conflict], [false, "A"]);
+    assert.match(r.reason, /#5 has a live lane in batch A/);
+    assert.deepEqual(b.list().queue, [], "a refused key holds no grant rank");
+    assert.equal(b.holder({ batch: "B", repo: "o/r", issue: 5, exclusive: true }), "A");
+    assert.equal(a.holder({ batch: "A", repo: "o/r", issue: 5, exclusive: true }), null, "its own batch is no conflict");
+    assert.equal(b.tryAcquire("B#6", { batch: "B", repo: "o/r", issue: 6, exclusive: true }, 4).ok, true, "another issue");
+    assert.equal(b.tryAcquire("C#5", { batch: "C", repo: "o/other", issue: 5, exclusive: true }, 4).ok, true, "another repo");
+    assert.equal(b.tryAcquire("D#5", { batch: "D", repo: null, issue: 5, exclusive: true }, 4).ok, true, "no repo: unchanged");
+    assert.equal(a.tryAcquire("A#5", { batch: "A", repo: "o/r", issue: 5, exclusive: true }, 4).ok, true, "a granted key stays granted");
+    assert.equal(b.tryAcquire("E#5", { batch: "E", repo: "o/r", issue: 5 }, null).ok, true, "not exclusive: unchanged");
+    b.release("E#5");
+    live.delete(201); // A's dispatcher dies with no lane: its slot is reclaimed
+    assert.equal(b.tryAcquire("B#5", { batch: "B", repo: "o/r", issue: 5, exclusive: true }, 4).ok, true);
+  });
+
+  it("two batches that both include issue N never run two lanes for N; the second defers naming the first and runs its other issues", async () => {
+    const { handle } = world();
+    const regA = handle(301), regB = handle(302);
+    const active = new Map(), maxActive = new Map(), ranB = [];
+    let releaseA;
+    const gateA = new Promise((r) => { releaseA = r; });
+    const lane = (n) => { active.set(n, (active.get(n) ?? 0) + 1); maxActive.set(n, Math.max(maxActive.get(n) ?? 0, active.get(n))); };
+    const pA = orchestrate({ issues: [5], readBody: async () => "", pollMs: 2, batchId: "bA", sched: { registry: regA, batch: "bA", repo: "o/r", cap: null, exclusive: true },
+      runOne: async (n) => { lane(n); await gateA; active.set(n, active.get(n) - 1); return { terminalReason: "merged", cost_usd: 0 }; } });
+    await until(() => active.get(5) === 1, "batch A's lane");
+    const rowsB = [];
+    const pB = orchestrate({ issues: [5, 6], readBody: async () => "", pollMs: 2, batchId: "bB", sched: { registry: regB, batch: "bB", repo: "o/r", cap: null, exclusive: true },
+      onUpdate: (r) => rowsB.push(r),
+      runOne: async (n) => { lane(n); ranB.push(n); active.set(n, active.get(n) - 1); return { terminalReason: "merged", cost_usd: 0 }; } });
+    await until(() => ranB.includes(6), "batch B's other issue");
+    const deferred = rowsB.filter((r) => r.issue === 5 && r.outcome === "deferred");
+    assert.equal(deferred.length, 1, "one row per other batch");
+    assert.match(deferred[0].detail, /live lane in batch bA/);
+    assert.ok(!ranB.includes(5), "no second lane while batch A runs #5");
+    releaseA();
+    await pA;
+    const done = await pB;
+    assert.deepEqual(done.map((r) => [r.issue, r.outcome]).sort(), [[5, "merged"], [6, "merged"]]);
+    assert.equal(maxActive.get(5), 1);
+  });
+});

package/bin/lean/schedd.test.mjs

@@ -214,6 +214,27 @@ await orchestrateFromCli(["1", "2", "--parallel", "2", "--repo", "o/r", "--no-pr
     } 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 {

package/bin/stats/efficiency.mjs

@@ -59,14 +59,18 @@ function parseLog(text) {
   return out;
 }
 
-/** Every RUN_START..RUN_TERMINAL slice of one run log (all of them, not only the last). */
+export const LANE_SHAPES = Object.freeze(["light", "upgraded", "full"]);
+
+/** Every RUN_START..RUN_TERMINAL slice of one run log (all of them, not only the last). `shape` (#4452): light (LIGHT_DONE), upgraded (LIGHT_UPGRADE) or full. */
 export function issueSlices(events) {
   const out = [];
   let cur = null;
   for (const e of Array.isArray(events) ? events : []) {
     if (!e || typeof e !== "object") continue;
-    if (e.event === "RUN_START") { cur = { startTs: e.ts ?? null, repo: e.repo ?? null, terminal: null, attempts: [] }; out.push(cur); continue; }
+    if (e.event === "RUN_START") { cur = { startTs: e.ts ?? null, repo: e.repo ?? null, terminal: null, shape: "full", attempts: [] }; out.push(cur); continue; }
     if (!cur) continue;
+    if (e.event === "LIGHT_DONE") cur.shape = "light";
+    else if (e.event === "LIGHT_UPGRADE") cur.shape = "upgraded";
     if (e.event === "PHASE_ATTEMPT_USAGE") {
       cur.attempts.push({ phase: e.phase ?? "other", trigger: e.trigger ?? null, restart_of: e.restart_of ?? null, model: e.model ?? null,
         turns: num(e.turns), cacheRead: num(e.usage?.cache_read_input_tokens), cost: costOf(e),
@@ -145,9 +149,18 @@ const group = (xs) => {
  */
 export function efficiencyMetrics({ entries = [], logs = new Map(), issues = null, repo = null, now = 0, notes = [] } = {}) {
   const merged = [];
+  const inScope = (row, settleAt) => issueSlices(logs.get(row.issue) ?? []).filter((s) => (!repo || !s.repo || s.repo === repo) && (!settleAt || !s.startTs || s.startTs <= settleAt));
+  // #4452: light/full split and upgrade rate over every lane of every row (all outcomes); cost is the #4407 delta sum
+  const shapes = Object.fromEntries(LANE_SHAPES.map((k) => [k, { n: 0, cost_usd: 0 }]));
+  for (const { row, settleAt } of entries) {
+    if (!Number.isSafeInteger(row?.issue)) continue;
+    for (const s of inScope(row, settleAt)) { const g = shapes[s.shape] ?? shapes.full; g.n++; g.cost_usd += sum(s.attempts.map((a) => a.cost)); }
+  }
+  for (const g of Object.values(shapes)) g.cost_usd = r(g.cost_usd, 1e6);
+  const lanes = { ...shapes, upgrade_rate: r(per(shapes.upgraded.n, shapes.light.n + shapes.upgraded.n)) };
   for (const { row, settleAt } of entries) {
     if (row?.outcome !== "merged") continue;
-    const slices = issueSlices(logs.get(row.issue) ?? []).filter((s) => (!repo || !s.repo || s.repo === repo) && (!settleAt || !s.startTs || s.startTs <= settleAt));
+    const slices = inScope(row, settleAt);
     const atts = slices.flatMap((s) => s.attempts), impl = atts.filter((a) => a.phase === "implement");
     const retries = Object.fromEntries(RETRY_CAUSES.map((c) => [c, 0]));
     for (const s of slices) for (const [c, k] of Object.entries(sliceRetries(s))) retries[c] += k;
@@ -156,7 +169,7 @@ export function efficiencyMetrics({ entries = [], logs = new Map(), issues = nul
     const term = [...slices].reverse().find((s) => s.terminal?.reason === "merged")?.terminal;
     merged.push({ issue: row.issue, slices: slices.length, cost: sum(atts.map((a) => a.cost)), implCost: sum(impl.map((a) => a.cost)),
       reviewCost: sum(atts.filter((a) => a.phase === "review").map((a) => a.cost)), implTurns: sum(impl.map((a) => a.turns)), implCache: sum(impl.map((a) => a.cacheRead)),
-      size: term?.size ?? laneSize({ labels: info?.labels ?? [] }) ?? "unknown", impl, retries, info, tools: laneTools(impl) });
+      size: term?.size ?? laneSize({ labels: info?.labels ?? [] }) ?? "unknown", impl, retries, info, tools: laneTools(impl), shape: slices.at(-1)?.shape ?? null });
   }
   const all = group(merged);
   const bySize = {};
@@ -202,10 +215,10 @@ export function efficiencyMetrics({ entries = [], logs = new Map(), issues = nul
     retries: { total, per_merge: r(per(total, merged.length), 100), by_cause: retries, lane_reruns: sum(merged.map((m) => Math.max(0, m.slices - 1))) },
     no_action: { lanes: sum(Object.values(noAction).map((g) => g.n)), cost_usd: r(sum(Object.values(noAction).map((g) => g.cost_usd)), 1e6),
       by_kind: Object.fromEntries(Object.entries(noAction).map(([k, g]) => [k, { ...g, cost_usd: r(g.cost_usd, 1e6) }])) },
-    quality, acceptance,
+    quality, acceptance, lanes,
     tool_calls_per_turn_p50: median(withTools.map((m) => m.tools.per_turn)), rereads_per_merge: withTools.length ? r(per(sum(withTools.map((m) => m.tools.rereads)), withTools.length), 100) : null,
     per_issue: merged.map((m) => ({ issue: m.issue, slices: m.slices, cost_usd: r(m.cost, 1e6), implement_usd: r(m.implCost, 1e6), implement_turns: m.implTurns,
-      implement_cache_read: m.implCache, size: m.size, retries: m.retries, ...(m.info ? { quality: issueQuality(m.info.body).tag } : {}),
+      implement_cache_read: m.implCache, size: m.size, retries: m.retries, ...(m.shape ? { shape: m.shape } : {}), ...(m.info ? { quality: issueQuality(m.info.body).tag } : {}),
       ...(m.tools ? { implement_tool_calls_per_turn: m.tools.per_turn, implement_rereads: m.tools.rereads } : {}) })),
     notes,
   };
@@ -315,5 +328,8 @@ export function formatEfficiencyLines(m, label = "") {
   lines.push(a ? `acceptance (7d after promotion): pass ${a.pass}/${a.pass + a.fail}${a.pass_rate == null ? "" : ` (${Math.round(a.pass_rate * 100)}%)`}, pending ${a.pending}, unprobed ${a.unprobed}`
     : "acceptance (7d after promotion): n/a");
   lines.push(`tools: calls/turn p50 ${f(m.tool_calls_per_turn_p50)}, re-reads (>=3x same path)/merge ${f(m.rereads_per_merge)}`); // #4410
+  const ln = m.lanes; // #4452
+  lines.push(ln ? `lanes: ${LANE_SHAPES.map((k) => `${k} ${ln[k]?.n ?? 0} (${usd(ln[k]?.cost_usd ?? 0)})`).join(", ")}; upgrade rate ${ln.upgrade_rate == null ? "n/a"
+    : `${Math.round(ln.upgrade_rate * 100)}% (${ln.upgraded?.n ?? 0}/${(ln.light?.n ?? 0) + (ln.upgraded?.n ?? 0)})`}` : "lanes: n/a");
   return lines;
 }

package/bin/stats/efficiency.test.mjs

@@ -115,11 +115,44 @@ describe("#4402 efficiencyMetrics", () => {
   });
   it("renders n/a, never NaN, for an empty cohort", () => {
     const lines = formatEfficiencyLines(efficiencyMetrics({}));
-    assert.equal(lines.length, 8);
+    assert.equal(lines.length, 9);
     assert.ok(!lines.some((l) => /NaN|undefined/.test(l)), lines.join("\n"));
     assert.match(lines[0], /^efficiency: merged 0, n\/a\/merge/);
     assert.equal(lines[6], "acceptance (7d after promotion): n/a");
     assert.equal(lines[7], "tools: calls/turn p50 n/a, re-reads (>=3x same path)/merge n/a");
+    assert.equal(lines[8], "lanes: light 0 ($0.00), upgraded 0 ($0.00), full 0 ($0.00); upgrade rate n/a");
+  });
+});
+
+describe("#4452 light/full split and upgrade rate", () => {
+  // issue 1: light, merged; 2: light then upgraded in the same run, merged; 3: full, merged; 4: light, failed; 5: upgraded, failed
+  const logs = new Map([
+    [1, [start("2026-10-22T10:00:00Z"), { event: "LIGHT_ELIGIBILITY", light: true }, att("implement", { trigger: "build", cost_usd: 0.9, cost_usd_delta: 0.4 }), { event: "LIGHT_DONE" }, att("review", { cost_usd: 0.05 }), term("merged", "merged")]],
+    [2, [start("2026-10-22T10:00:00Z"), att("implement", { trigger: "build", cost_usd_delta: 0.3 }), { event: "LIGHT_UPGRADE", reasons: [{ code: "diff_lines" }] }, att("implement", { trigger: "plan", cost_usd_delta: 0.5 }), term("merged", "merged")]],
+    [3, [start("2026-10-22T10:00:00Z"), att("implement", { trigger: "plan", cost_usd_delta: 0.6 }), att("implement", { trigger: "build", cost_usd: 1.2, cost_usd_delta: 0.4 }), term("merged", "merged")]],
+    [4, [start("2026-10-22T10:00:00Z"), att("implement", { trigger: "build", cost_usd_delta: 0.2 }), { event: "LIGHT_DONE" }, term("failed", "ci.red")]],
+    [5, [start("2026-10-22T10:00:00Z"), att("implement", { trigger: "build", cost_usd_delta: 0.1 }), { event: "LIGHT_UPGRADE" }, term("failed", "conformance.unimplemented")]],
+  ]);
+  const entries = [1, 2, 3, 4, 5].map((issue) => ({ row: { issue, outcome: issue <= 3 ? "merged" : "failed" }, settleAt: null }));
+  const m = efficiencyMetrics({ entries, logs, repo: "o/r" });
+
+  it("tags each lane slice by shape from LIGHT_DONE / LIGHT_UPGRADE", () => {
+    assert.deepEqual(issueSlices(logs.get(1)).map((s) => s.shape), ["light"]);
+    assert.deepEqual(issueSlices(logs.get(2)).map((s) => s.shape), ["upgraded"]);
+    assert.deepEqual(issueSlices(logs.get(3)).map((s) => s.shape), ["full"]);
+  });
+  it("splits every lane (all outcomes) by shape with true #4407 delta costs and computes the upgrade rate", () => {
+    assert.deepEqual(m.lanes, {
+      light: { n: 2, cost_usd: 0.65 }, // 0.4 delta (not the 0.9 running total) + 0.05 review + 0.2
+      upgraded: { n: 2, cost_usd: 0.9 },
+      full: { n: 1, cost_usd: 1 }, // 0.6 + 0.4 delta, not 1.2
+      upgrade_rate: 0.5,
+    });
+    assert.deepEqual(m.per_issue.map((x) => [x.issue, x.shape]), [[1, "light"], [2, "upgraded"], [3, "full"]]);
+  });
+  it("the batch report prints the split and the upgrade rate", () => {
+    const lines = formatEfficiencyLines(m);
+    assert.equal(lines.at(-1), "lanes: light 2 ($0.65), upgraded 2 ($0.90), full 1 ($1.00); upgrade rate 50% (2/4)");
   });
 });
 
@@ -142,7 +175,7 @@ describe("#4410 tool calls per turn and re-reads", () => {
     const p = Object.fromEntries(m.per_issue.map((x) => [x.issue, x]));
     assert.equal(p[1].implement_tool_calls_per_turn, 1.5); assert.equal(p[1].implement_rereads, 2);
     assert.equal("implement_tool_calls_per_turn" in p[4], false);
-    assert.equal(formatEfficiencyLines(m).at(-1), "tools: calls/turn p50 1.50, re-reads (>=3x same path)/merge 1.00");
+    assert.equal(formatEfficiencyLines(m).find((l) => l.startsWith("tools:")), "tools: calls/turn p50 1.50, re-reads (>=3x same path)/merge 1.00");
   });
   it("null without tool data (older logs)", () => {
     const e = efficiencyMetrics({ entries: [entries[3]], logs, repo: "o/r", now: NOW });

package/bin/stats/index.mjs

@@ -11,10 +11,10 @@ import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { aggregate, computeAlerts, DEFAULT_ALERTS, DEFAULT_MIN_N } from "./aggregate.mjs";
 import { defaultGh, fetchGithubRecords, isValidRepo, toModel } from "./github-source.mjs";
-import { readLanes, readLocalRuns, runsDir } from "./local-source.mjs";
+import { readLanes, readLocalLaneRuns, readLocalRuns, runsDir } from "./local-source.mjs";
 import { parseForgeYaml } from "../forge-utils.mjs";
 import { renderCompact, renderJson, renderMarkdown } from "./render.mjs";
-import { edgeQuery, parseEdge, verdictMix, contextPackAb, renderContextAb, builderTierReport, renderTiers } from "./query.mjs";
+import { edgeQuery, parseEdge, verdictMix, contextPackAb, renderContextAb, builderTierReport, renderTiers, exploreAb, renderExploreAb, laneProfileReport, renderLaneProfiles } from "./query.mjs";
 import { batchEfficiency, windowEfficiency, formatEfficiencyLines, parseWindows } from "./efficiency.mjs";
 import { batchRoot } from "../lean/batch.mjs";
 
@@ -52,6 +52,10 @@ Context-pack A/B (forge#4275; local run logs only, no GitHub crawl):
   --context-ab          first-pass yield, builder turns, cache tokens and cost per lane type (rerun, child,
                         first) and context_pack mode (on, off, shadow); --json for JSON
 
+Explorer A/B (forge#4418; local run logs only, every run of each log, no GitHub crawl):
+  --explore-ab          builder turns, builder cache-read, merge and conformance rates per size (S, M, L) and
+                        lean.explore mode (on, off), plus the same issues run in both modes; --json for JSON
+
 Efficiency (forge#4402; local batch dirs and run logs, gh only for merged issues' bodies, labels and probes):
   --efficiency          $/merge, turns/merge, context/turn per size and model, retries/merge by cause, no-action
                         lanes, issue quality vs cost and the acceptance pass rate 7 days after promotion
@@ -61,10 +65,15 @@ Efficiency (forge#4402; local batch dirs and run logs, gh only for merged issues
 Builder model tiers (forge#4394; local run logs only, no GitHub crawl):
   --tiers               merge, conformance and post-merge-rework rates, first-pass yield and cost per builder tier
                         (mid, mid->top escalated, top) and routing class; --json for JSON
+
+Lane profile baseline (forge#4436; local run logs only, every run of each issue, no GitHub crawl):
+  --lane-profile        first-turn baseline_tokens per lane profile (full, memory-off, lane) and phase, and the
+                        conformance rate per profile; --json for JSON
+  --issues <list>       pin the report to these issues (comma list), for a before/after on the same issue set
 `;
 
 export function parseArgs(argv) {
-  const o = { since: null, repo: null, edge: null, milestone: null, contextAb: false, tiers: false, efficiency: false, batch: null, windows: null, json: false, refresh: false, compact: false, local: true, cache: true, minN: DEFAULT_MIN_N, releaseTimes: null, help: false };
+  const o = { since: null, repo: null, edge: null, milestone: null, contextAb: false, exploreAb: false, tiers: false, laneProfile: false, issues: null, efficiency: false, batch: null, windows: null, json: false, refresh: false, compact: false, local: true, cache: true, minN: DEFAULT_MIN_N, releaseTimes: null, help: false };
   const val = (i, name) => {
     const v = argv[i + 1];
     if (v == null || v.startsWith("--")) throw new Error(`${name} needs a value`);
@@ -81,7 +90,10 @@ export function parseArgs(argv) {
     else if (name === "--edge") { const v = take(); if (!parseEdge(v)) throw new Error("--edge must be FROM:TO"); o.edge = v; }
     else if (name === "--milestone") o.milestone = take();
     else if (name === "--context-ab") o.contextAb = true;
+    else if (name === "--explore-ab") o.exploreAb = true;
     else if (name === "--tiers") o.tiers = true;
+    else if (name === "--lane-profile") o.laneProfile = true;
+    else if (name === "--issues") { const v = take(); if (!/^[1-9]\d*(,[1-9]\d*)*$/.test(v)) throw new Error("--issues must be a comma list of issue numbers"); o.issues = v.split(",").map(Number); }
     else if (name === "--efficiency") o.efficiency = true;
     else if (name === "--batch") { const v = take(); if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(v)) throw new Error(`invalid --batch id: ${v}`); o.batch = v; }
     else if (name === "--window") o.windows = parseWindows(take());
@@ -214,10 +226,18 @@ export async function buildReport(opts, deps = {}) {
     const runs = (deps.localRuns ?? readLocalRuns(runsDir(env))).filter((r) => r.repo == null || r.repo === repo);
     return { repo, sources: { local: { runs: runs.length } }, query: { context_ab: contextPackAb(runs) } };
   }
+  if (opts.exploreAb) { // forge#4418: run logs only, every RUN_START slice
+    const runs = (deps.localRuns ?? readLocalLaneRuns(runsDir(env))).filter((r) => r.repo == null || r.repo === repo);
+    return { repo, sources: { local: { runs: runs.length } }, query: { explore_ab: exploreAb(runs) } };
+  }
   if (opts.tiers) { // forge#4394: run logs only
     const runs = (deps.localRuns ?? readLocalRuns(runsDir(env))).filter((r) => r.repo == null || r.repo === repo);
     return { repo, sources: { local: { runs: runs.length } }, query: { tiers: builderTierReport(runs) } };
   }
+  if (opts.laneProfile) { // forge#4436: run logs only, every RUN_START slice
+    const runs = (deps.localRuns ?? readLocalRuns(runsDir(env), { allSlices: true })).filter((r) => r.repo == null || r.repo === repo);
+    return { repo, sources: { local: { runs: runs.length } }, query: { lane_profile: laneProfileReport(runs, { issues: opts.issues }) } };
+  }
   const bound = sinceToTimestamp(opts.since, releaseTimes);
   if (bound.note) (deps.warn ?? ((m) => process.stderr.write(`forgedock stats: ${m}\n`)))(bound.note);
   const gh = await fetchGithubRecords({ repo, since: bound.since, refresh: opts.refresh, useCache: opts.cache, gh: deps.gh, env,
@@ -254,6 +274,7 @@ export async function runStats(argv, deps = {}) {
   }
   try {
     const report = await buildReport(opts, { onProgress: makeProgressPrinter(), ...deps });
+    if (report.query?.lane_profile && !opts.json) { process.stdout.write(`${renderLaneProfiles(report.query.lane_profile)}\n`); return 0; }
     if (report.query?.tiers && !opts.json) { process.stdout.write(`${renderTiers(report.query.tiers)}\n`); return 0; }
     if (report.query?.efficiency && !opts.json) {
       const e = report.query.efficiency;
@@ -263,6 +284,7 @@ export async function runStats(argv, deps = {}) {
       return 0;
     }
     if (report.query?.context_ab && !opts.json) { process.stdout.write(`${renderContextAb(report.query.context_ab)}\n`); return 0; }
+    if (report.query?.explore_ab && !opts.json) { process.stdout.write(`${renderExploreAb(report.query.explore_ab)}\n`); return 0; }
     process.stdout.write(`${opts.json || report.query ? renderJson(report) : opts.compact ? renderCompact(report) : renderMarkdown(report)}\n`);
     return 0;
   } catch (err) {

package/bin/stats/local-source.mjs

@@ -58,7 +58,7 @@ export function summariseLog(events, fallbackIssue = null) {
   const usage = ev.filter((e) => e.event === "PHASE_ATTEMPT_USAGE");
   const builderCalls = usage.filter((e) => e.phase === "implement");
   const reviewCalls = usage.filter((e) => e.phase === "review").length;
-  const contextPack = { mode: term?.context_pack ?? cp?.mode ?? "off", laneType: term?.lane_type ?? cp?.lane_type ?? null };
+  const contextPack = { mode: term?.context_pack ?? cp?.mode ?? "off", laneType: term?.lane_type ?? cp?.lane_type ?? null, ab: (term?.context_ab ?? cp?.context_ab) === true };
   const startTs = start.ts ?? null;
   const endTs = finished ? ev[t].ts ?? null : null;
   const a = Date.parse(startTs ?? ""); const b = Date.parse(endTs ?? "");
@@ -76,7 +76,15 @@ export function summariseLog(events, fallbackIssue = null) {
     pitfallsMatched: Number.isInteger(term?.pitfalls_matched) ? term.pitfalls_matched
       : Array.isArray(cp?.pitfalls) ? cp.pitfalls.filter((p) => p?.match === "files").length : null,
     builderTurns: builderCalls.reduce((x, e) => x + n(e.turns), 0),
+    // #4418: the explorer A/B tag (null before #4391 wrote it) and the main-session (plan + build) cache-read
+    explore: term?.explore === "on" || term?.explore === "off" ? term.explore : null,
+    builderCacheRead: builderCalls.reduce((x, e) => x + n(e.usage?.cache_read_input_tokens), 0),
     size: term?.turns?.size ?? null, // #4409: S|M|L from the lane's turn record, buckets the admission estimate history
+    // #4444: cache-read alone (per-merge A/B metric) and the implement attempt (builder calls other than the plan call)
+    cacheReadTokens: usage.reduce((x, e) => x + n(e.usage?.cache_read_input_tokens), 0),
+    implementAttempt: implementAttemptOf(builderCalls),
+    // #4444: the implement attempt of the earliest finished first/child run in this log, the same-issue baseline of a rerun
+    firstRunAttempt: firstRunAttemptOf(events.slice(0, s)),
     cacheTokens: usage.reduce((x, e) => x + n(e.usage?.cache_read_input_tokens) + n(e.usage?.cache_creation_input_tokens), 0),
     costUsd: usage.reduce((x, e) => x + n(costOf(e)), 0),
     // #4394: the builder tier (RUN_TERMINAL builder_*, else the BUILDER_ROUTE / BUILDER_ESCALATED events); null before routing
@@ -88,9 +96,19 @@ export function summariseLog(events, fallbackIssue = null) {
     reworkedMerges: earlierMergedRoutes(events.slice(0, s)),
     // first pass: merged off one plan + one implement call, at most one review, no CI fix round
     firstPass: finished && term?.reason === "merged" && builderCalls.length <= 2 && reviewCalls <= 1 && !ev.some((e) => e.event === "CI_FIX_ROUND"),
+    // #4436: the lane profile (#4395) of this slice's sessions ("mixed" when they differ, null before the field) and the
+    // fresh sessions' first-turn baseline_tokens per phase (resumed sessions carry none)
+    laneProfile: profileOf(usage),
+    baselines: usage.reduce((acc, e) => { if (Number.isFinite(e.baseline_tokens)) (acc[e.phase ?? "other"] ??= []).push(e.baseline_tokens); return acc; }, {}),
   };
 }
 
+/** #4436: the one lane_profile of the usage records, "mixed" when they differ, null when none carries it. */
+function profileOf(usage) {
+  const ps = new Set(usage.map((e) => e.lane_profile).filter((p) => typeof p === "string" && p));
+  return ps.size === 0 ? null : ps.size === 1 ? [...ps][0] : "mixed";
+}
+
 /** #4394: {tier, class, escalated, model} of a lane, or null when it computed no builder route. */
 function routeOf(term, ev) {
   if (typeof term?.builder_tier === "string") {
@@ -101,6 +119,31 @@ function routeOf(term, ev) {
   return { tier: r.tier ?? null, class: r.class ?? null, escalated: ev.some((e) => e.event === "BUILDER_ESCALATED"), model: r.model ?? null };
 }
 
+/** #4444: {turns, output_tokens} of the builder calls other than the plan call; null when there is none. */
+function implementAttemptOf(builderCalls) {
+  const traced = builderCalls.some((e) => typeof e.trigger === "string");
+  const calls = traced ? builderCalls.filter((e) => e.trigger !== "plan") : builderCalls.slice(1);
+  if (!calls.length) return null;
+  return { turns: calls.reduce((x, e) => x + n(e.turns), 0), output_tokens: calls.reduce((x, e) => x + n(e.usage?.output_tokens), 0) };
+}
+
+/** #4444: implementAttemptOf for the earliest finished RUN_START slice of `events` whose lane type was first or child. */
+function firstRunAttemptOf(events) {
+  let slice = null;
+  const slices = [];
+  for (const e of events) {
+    if (e.event === "RUN_START") { slice = []; slices.push(slice); }
+    if (slice) slice.push(e);
+  }
+  for (const sl of slices) {
+    const term = [...sl].reverse().find((e) => e.event === "RUN_TERMINAL");
+    if (!["first", "child"].includes(term?.lane_type)) continue;
+    const att = implementAttemptOf(sl.filter((e) => e.event === "PHASE_ATTEMPT_USAGE" && e.phase === "implement"));
+    if (att) return att;
+  }
+  return null;
+}
+
 /** #4394: the routes ({tier, class, escalated, model}) of the RUN_START slices in `events` that ended merged with a route. */
 function earlierMergedRoutes(events) {
   const out = [];
@@ -119,21 +162,32 @@ function earlierMergedRoutes(events) {
   return out;
 }
 
-/** All run summaries in `dir` (a missing dir or an unreadable log yields nothing, never an error). */
-export function readLocalRuns(dir = runsDir()) {
+/**
+ * All run summaries in `dir` (a missing dir or an unreadable log yields nothing, never an error). One per log (its last
+ * RUN_START slice); with `allSlices` (#4436) one per RUN_START slice, so a before and an after run of one issue both count.
+ */
+export function readLocalRuns(dir = runsDir(), { allSlices = false } = {}) {
   if (!existsSync(dir)) return [];
   const runs = [];
   for (const f of readdirSync(dir).sort()) {
     if (!f.endsWith(".jsonl")) continue;
     try {
       const m = /(?:^|__)(\d+)\.jsonl$/.exec(f); // #4432: `<issue>.jsonl` or `<owner>__<repo>__<issue>.jsonl`
-      const sum = summariseLog(parseLog(readFileSync(join(dir, f), "utf8")), m ? Number(m[1]) : null);
-      if (sum) runs.push({ ...sum, mtimeTs: new Date(statSync(join(dir, f)).mtimeMs).toISOString() });
+      const events = parseLog(readFileSync(join(dir, f), "utf8"));
+      const starts = allSlices ? events.flatMap((e, i) => (e.event === "RUN_START" ? [i] : [])) : [events.length];
+      const mtimeTs = new Date(statSync(join(dir, f)).mtimeMs).toISOString();
+      starts.forEach((_, k) => {
+        const sum = summariseLog(allSlices ? events.slice(0, starts[k + 1] ?? events.length) : events, m ? Number(m[1]) : null);
+        if (sum) runs.push({ ...sum, mtimeTs });
+      });
     } catch { /* unreadable log */ }
   }
   return runs;
 }
 
+/** #4418: every RUN_START slice (readLocalRuns allSlices), so an on run and an off run of the same issue both count. */
+export const readLocalLaneRuns = (dir = runsDir()) => readLocalRuns(dir, { allSlices: true });
+
 /**
  * forge#4354: one lane per RUN_START..next-RUN_START slice (every slice, not only the last), with the fail-soft events the
  * alert pass rates: DEPS_PREPARED rows, TOOLCHAIN_WARNING texts, deferred-to-ci precheck commands and the terminal code.