forgedock 1.31.0 → 1.32.1

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.

package/bin/stats/query.mjs

@@ -85,17 +85,55 @@ export function contextPackAb(runs) {
     for (const mode of ["on", "off", "shadow"]) {
       const rs = runs.filter((r) => r?.finished && r.contextPack?.laneType === lt && r.contextPack?.mode === mode);
       out[lt][mode] = { n: rs.length, first_pass_yield: mean(rs.map((r) => (r.firstPass ? 1 : 0))), builder_turns: mean(rs.map((r) => r.builderTurns ?? 0)),
-        cache_tokens: mean(rs.map((r) => r.cacheTokens ?? 0)), cost_usd: mean(rs.map((r) => r.costUsd ?? 0)) };
+        cache_tokens: mean(rs.map((r) => r.cacheTokens ?? 0)), cost_usd: mean(rs.map((r) => r.costUsd ?? 0)), ...perMerge(rs, lt) };
     }
   }
+  out.recovery = recoveryVsFirst(runs);
   return out;
 }
 
+const round4 = (v) => Math.round(v * 1e4) / 1e4;
+/**
+ * #4444: per-merge A/B metrics of one cell: builder turns and cache-read over the cell's runs divided by its merges (null
+ * without a merge), and rework rate: runs that were remediated, followed an earlier merge, or are a rerun lane, over n.
+ */
+function perMerge(rs, lt) {
+  const merged = rs.filter((r) => r.reason === "merged").length;
+  const sum = (f) => rs.reduce((x, r) => x + (Number.isFinite(f(r)) ? f(r) : 0), 0);
+  const reworked = rs.filter((r) => r.remediated || (r.reworkedMerges?.length ?? 0) > 0 || lt === "rerun").length;
+  return { merged, turns_per_merge: merged ? round4(sum((r) => r.builderTurns) / merged) : null,
+    cache_read_per_merge: merged ? round4(sum((r) => r.cacheReadTokens) / merged) : null, rework_rate: rs.length ? round4(reworked / rs.length) : null };
+}
+
+/**
+ * #4444 (R8): a rerun lane's implement attempt against the first run on the same issue. The baseline is the earlier
+ * first/child slice of the rerun's own log (firstRunAttempt), else the earliest finished first/child run of the same
+ * repo+issue in `runs`. Ratios are rerun / first per pair (a zero baseline is skipped); null without a pair.
+ */
+export function recoveryVsFirst(runs) {
+  const key = (r) => `${String(r?.repo ?? "").toLowerCase()}#${r?.issue}`;
+  const firsts = new Map();
+  for (const r of [...runs].filter((x) => x?.finished && ["first", "child"].includes(x.contextPack?.laneType) && x.implementAttempt)
+    .sort((a, b) => String(a.startTs ?? "").localeCompare(String(b.startTs ?? "")))) if (!firsts.has(key(r))) firsts.set(key(r), r.implementAttempt);
+  const turnR = [], outR = [];
+  for (const r of runs) {
+    if (!r?.finished || r.contextPack?.laneType !== "rerun" || !r.implementAttempt) continue;
+    const base = r.firstRunAttempt ?? firsts.get(key(r));
+    if (!base) continue;
+    if (base.turns > 0) turnR.push(r.implementAttempt.turns / base.turns);
+    if (base.output_tokens > 0) outR.push(r.implementAttempt.output_tokens / base.output_tokens);
+  }
+  const mean = (xs) => (xs.length ? round4(xs.reduce((a, b) => a + b, 0) / xs.length) : null);
+  return { pairs: Math.max(turnR.length, outR.length), mean_turn_ratio: mean(turnR), mean_output_ratio: mean(outR) };
+}
+
 /** Markdown table for contextPackAb. */
 export function renderContextAb(ab) {
   const f = (v) => (v == null ? "n/a" : String(v));
-  const rows = CONTEXT_LANE_TYPES.flatMap((lt) => ["on", "off", "shadow"].map((m) => { const g = ab[lt][m]; return `| ${lt} | ${m} | ${g.n} | ${f(g.first_pass_yield)} | ${f(g.builder_turns)} | ${f(g.cache_tokens)} | ${f(g.cost_usd)} |`; }));
-  return `| Lane type | Mode | n | First-pass yield | Builder turns | Cache tokens | Cost USD |\n| --- | --- | --- | --- | --- | --- | --- |\n${rows.join("\n")}`;
+  const rows = CONTEXT_LANE_TYPES.flatMap((lt) => ["on", "off", "shadow"].map((m) => { const g = ab[lt][m]; return `| ${lt} | ${m} | ${g.n} | ${f(g.first_pass_yield)} | ${f(g.builder_turns)} | ${f(g.cache_tokens)} | ${f(g.cost_usd)} | ${f(g.merged)} | ${f(g.turns_per_merge)} | ${f(g.cache_read_per_merge)} | ${f(g.rework_rate)} |`; }));
+  const rc = ab.recovery; // #4444: R8, rerun implement attempt vs the first run on the same issue
+  const rec = rc ? `\n\nRecovery vs first run (same issue): ${rc.pairs} pair(s), implement turns ratio ${f(rc.mean_turn_ratio)}, output tokens ratio ${f(rc.mean_output_ratio)}` : "";
+  return `| Lane type | Mode | n | First-pass yield | Builder turns | Cache tokens | Cost USD | Merged | Turns/merge | Cache-read/merge | Rework rate |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n${rows.join("\n")}${rec}`;
 }
 
 /**
@@ -145,3 +183,95 @@ export function renderTiers(rep) {
   const rows = (rep?.rows ?? []).map((g) => `| ${g.tier} | ${g.class} | ${g.n} | ${f(g.merge_rate)} | ${f(g.conformance_rate)} (${g.reviewed}) | ${f(g.post_merge_rework_rate)} (${g.merges}) | ${f(g.first_pass_yield)} | ${f(g.cost_usd)} |`);
   return `| Tier | Class | n | Merge rate | Conformance rate (reviewed) | Post-merge rework (merges) | First-pass yield | Cost USD |\n| --- | --- | --- | --- | --- | --- | --- | --- |\n${rows.length ? rows.join("\n") : "| none | | 0 | | | | | |"}\n\n${rep?.unrouted ?? 0} finished run(s) without a builder route (before #4394) left out.`;
 }
+
+/**
+ * forge#4418: the explorer A/B (#4391) over per-slice run summaries (local-source.mjs readLocalLaneRuns), per size bucket
+ * (RUN_TERMINAL turns.size, set before the build) and RUN_TERMINAL `explore` mode. builder_turns / builder_cache_read:
+ * means over the plan + build calls. merge_rate: merged / n. conformance_rate: as builderTierReport. `paired` keeps only
+ * issues with a finished run in both modes. Untagged runs (before #4391) are counted, never folded into `off`.
+ */
+export const EXPLORE_SIZES = Object.freeze(["S", "M", "L", "unsized"]);
+const EXPLORE_MODES = ["on", "off"];
+export function exploreAb(runs) {
+  const mean = (xs) => (xs.length ? Math.round((xs.reduce((a, b) => a + b, 0) / xs.length) * 1e4) / 1e4 : null);
+  const rate = (k, n) => (n ? Math.round((k / n) * 1e4) / 1e4 : null);
+  const finished = (runs ?? []).filter((r) => r?.finished);
+  const tagged = finished.filter((r) => EXPLORE_MODES.includes(r.explore));
+  const stats = (rs) => {
+    const reviewed = rs.filter((r) => r.reachedReview);
+    const conforming = reviewed.filter((r) => !r.conformanceRound && (r.shadowWould == null || r.shadowWould === "conforms"));
+    return { n: rs.length, builder_turns: mean(rs.map((r) => r.builderTurns ?? 0)), builder_cache_read: mean(rs.map((r) => r.builderCacheRead ?? 0)),
+      merge_rate: rate(rs.filter((r) => r.reason === "merged").length, rs.length), conformance_rate: rate(conforming.length, reviewed.length), reviewed: reviewed.length };
+  };
+  const bySize = {};
+  for (const size of EXPLORE_SIZES) {
+    bySize[size] = {};
+    for (const mode of EXPLORE_MODES) bySize[size][mode] = stats(tagged.filter((r) => (EXPLORE_SIZES.includes(r.size) ? r.size : "unsized") === size && r.explore === mode));
+  }
+  const key = (r) => `${r.repo ?? ""}#${r.issue}`;
+  const both = new Set(tagged.filter((r) => r.explore === "on").map(key).filter((k) => tagged.some((r) => r.explore === "off" && key(r) === k)));
+  const pairedRuns = tagged.filter((r) => both.has(key(r)));
+  const paired = { issues: both.size };
+  for (const mode of EXPLORE_MODES) paired[mode] = stats(pairedRuns.filter((r) => r.explore === mode));
+  return { by_size: bySize, paired, untagged: finished.length - tagged.length };
+}
+
+/** Markdown tables for exploreAb. */
+export function renderExploreAb(ab) {
+  const f = (v) => (v == null ? "n/a" : String(v));
+  const row = (label, mode, g) => `| ${label} | ${mode} | ${g.n} | ${f(g.builder_turns)} | ${f(g.builder_cache_read)} | ${f(g.merge_rate)} | ${f(g.conformance_rate)} (${g.reviewed}) |`;
+  const head = "| Size | Explore | n | Builder turns | Builder cache-read | Merge rate | Conformance rate (reviewed) |\n| --- | --- | --- | --- | --- | --- | --- |";
+  const sizes = EXPLORE_SIZES.flatMap((s) => EXPLORE_MODES.map((m) => row(s, m, ab.by_size[s][m])));
+  const paired = EXPLORE_MODES.map((m) => row("paired", m, ab.paired[m]));
+  return `${head}\n${sizes.join("\n")}\n\nSame issues in both modes: ${ab.paired.issues}\n\n${head}\n${paired.join("\n")}\n\n${ab.untagged} finished run(s) without an explore tag (before #4391) left out.`;
+}
+
+/**
+ * forge#4436: the #4395 lane baseline before/after, over local run summaries (every RUN_START slice). Finished runs,
+ * optionally pinned to an issue set, grouped by lane profile (null → unknown). Per profile and phase: fresh-session
+ * first-turn baseline_tokens (sessions, median, mean). Per profile: conformance_rate (the builderTierReport rule) and
+ * shadow_blocks (reviewed runs with a would-block verdict). issues_in_all: issues with a finished run under every profile.
+ */
+export const LANE_PROFILES = Object.freeze(["full", "memory-off", "lane", "mixed", "unknown"]);
+export function laneProfileReport(runs, { issues = null } = {}) {
+  const pin = Array.isArray(issues) && issues.length ? new Set(issues) : null;
+  const rate = (k, n) => (n ? Math.round((k / n) * 1e4) / 1e4 : null);
+  const groups = new Map();
+  for (const r of runs ?? []) {
+    if (!r?.finished || (pin && !pin.has(r.issue))) continue;
+    const name = typeof r.laneProfile === "string" && r.laneProfile ? r.laneProfile : "unknown";
+    const g = groups.get(name) ?? { profile: name, n: 0, issues: new Set(), reviewed: 0, conforming: 0, shadow_blocks: 0, phases: {} };
+    groups.set(name, g);
+    g.n++;
+    if (r.issue != null) g.issues.add(r.issue);
+    if (r.reachedReview) {
+      g.reviewed++;
+      if (!r.conformanceRound && (r.shadowWould == null || r.shadowWould === "conforms")) g.conforming++;
+      if (typeof r.shadowWould === "string" && r.shadowWould !== "conforms") g.shadow_blocks++;
+    }
+    for (const [phase, xs] of Object.entries(r.baselines ?? {})) (g.phases[phase] ??= []).push(...xs.filter(Number.isFinite));
+  }
+  const stat = (xs) => {
+    if (!xs.length) return { median: null, mean: null };
+    const s = [...xs].sort((a, b) => a - b), m = s.length >> 1;
+    return { median: Math.round(s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2), mean: Math.round(s.reduce((a, b) => a + b, 0) / s.length) };
+  };
+  const rank = (p) => { const i = LANE_PROFILES.indexOf(p); return i < 0 ? LANE_PROFILES.length : i; };
+  const profiles = [...groups.values()].sort((a, b) => rank(a.profile) - rank(b.profile) || a.profile.localeCompare(b.profile))
+    .map((g) => ({ profile: g.profile, n: g.n, issues: [...g.issues].sort((a, b) => a - b), reviewed: g.reviewed, conformance_rate: rate(g.conforming, g.reviewed),
+      shadow_blocks: g.shadow_blocks, phases: Object.keys(g.phases).sort().map((phase) => ({ phase, sessions: g.phases[phase].length, ...stat(g.phases[phase]) })) }));
+  const issuesInAll = profiles.length ? profiles[0].issues.filter((i) => profiles.every((p) => p.issues.includes(i))) : [];
+  return { profiles, issues_in_all: issuesInAll };
+}
+
+/** Markdown tables for laneProfileReport. */
+export function renderLaneProfiles(rep) {
+  const f = (v) => (v == null ? "n/a" : String(v));
+  const ps = rep?.profiles ?? [];
+  const base = ps.flatMap((p) => (p.phases.length ? p.phases : [{ phase: "n/a", sessions: 0, median: null, mean: null }])
+    .map((x) => `| ${p.profile} | ${x.phase} | ${x.sessions} | ${f(x.median)} | ${f(x.mean)} |`));
+  const conf = ps.map((p) => `| ${p.profile} | ${p.n} | ${f(p.conformance_rate)} (${p.reviewed}) | ${p.shadow_blocks} |`);
+  return `| Profile | Phase | Sessions | Median baseline | Mean baseline |\n| --- | --- | --- | --- | --- |\n${base.length ? base.join("\n") : "| none | | 0 | | |"}\n\n`
+    + `| Profile | Runs | Conformance rate (reviewed) | Shadow would-block |\n| --- | --- | --- | --- |\n${conf.length ? conf.join("\n") : "| none | 0 | | |"}\n\n`
+    + `Issues with a finished run under every profile: ${rep?.issues_in_all?.length ? rep.issues_in_all.map((i) => `#${i}`).join(", ") : "none"}`;
+}

package/bin/stats/stats.test.mjs

@@ -12,9 +12,9 @@ import { aggregate, compareVersions, computeAlerts, DEFAULT_ALERTS, percentile }
 import { cacheDir } from "./cache.mjs";
 import { fetchGithubRecords, parseTelemetryComments, runsFromRecords, toModel } from "./github-source.mjs";
 import { buildReport, makeProgressPrinter, parseArgs, parseSince, readAlertConfig, runStats, sinceToTimestamp } from "./index.mjs";
-import { lanesOfLog, readLanes, readLocalRuns, summariseLog } from "./local-source.mjs";
+import { lanesOfLog, readLanes, readLocalLaneRuns, readLocalRuns, summariseLog } from "./local-source.mjs";
 import { renderAlerts, 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";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const fx = (f) => join(here, "fixtures", f);
@@ -538,7 +538,7 @@ describe("context-pack A/B over run logs (forge#4275)", () => {
 
   it("summariseLog carries mode, lane type, builder turns, cache tokens, cost and first-pass", () => {
     const s = summariseLog(log("on", "child"));
-    assert.deepEqual(s.contextPack, { mode: "on", laneType: "child" });
+    assert.deepEqual(s.contextPack, { mode: "on", laneType: "child", ab: false });
     assert.deepEqual([s.builderTurns, s.cacheTokens, s.costUsd, s.firstPass], [10, 2130, 1.1, true]);
     assert.equal(summariseLog(log("on", "child", { builds: 4 })).firstPass, false);
     assert.equal(summariseLog(log("on", "child", { reason: "needs-human" })).firstPass, false);
@@ -553,8 +553,8 @@ describe("context-pack A/B over run logs (forge#4275)", () => {
     const runs = [log("on", "first"), log("on", "first", { builds: 4, reviews: 2 }), log("off", "first"), log("shadow", "rerun"),
       [{ event: "RUN_START", issue: 2 }, { event: "RUN_TERMINAL", reason: "merged" }]].map((l) => summariseLog(l));
     const ab = contextPackAb(runs);
-    assert.deepEqual(Object.keys(ab), ["rerun", "child", "first"]);
-    assert.deepEqual(ab.first.on, { n: 2, first_pass_yield: 0.5, builder_turns: 15, cache_tokens: 3195, cost_usd: 1.65 });
+    assert.deepEqual(Object.keys(ab), ["rerun", "child", "first", "recovery"]);
+    assert.deepEqual(ab.first.on, { n: 2, first_pass_yield: 0.5, builder_turns: 15, cache_tokens: 3195, cost_usd: 1.65, merged: 2, turns_per_merge: 15, cache_read_per_merge: 3150, rework_rate: 0 });
     assert.equal(ab.first.off.n, 1); assert.equal(ab.first.off.first_pass_yield, 1);
     assert.equal(ab.rerun.shadow.n, 1); assert.equal(ab.child.on.n, 0); assert.equal(ab.child.on.cost_usd, null);
     assert.match(renderContextAb(ab), /\| first \| on \| 2 \| 0\.5 \| 15 \| 3195 \| 1\.65 \|/);
@@ -567,6 +567,100 @@ describe("context-pack A/B over run logs (forge#4275)", () => {
   });
 });
 
+describe("explorer A/B over run logs (forge#4418)", () => {
+  const use = (phase, turns, cr) => ({ event: "PHASE_ATTEMPT_USAGE", phase, turns, cost_usd: 0.5, usage: { cache_read_input_tokens: cr, cache_creation_input_tokens: 10, output_tokens: 1 } });
+  const slice = (issue, explore, { size = "M", turns = 5, cr = 1000, reason = "merged", triggers = ["plan", "build"], review = true } = {}) => [
+    { event: "RUN_START", issue, repo: "o/r", run: `r${issue}${explore}` },
+    ...triggers.map((t) => ({ ...use("implement", turns, cr), trigger: t })), ...(review ? [use("review", 2, 100)] : []),
+    { event: "RUN_TERMINAL", reason, code: "x", ...(explore ? { explore } : {}), ...(size ? { turns: { size, budget: 100, build: 9 } } : {}) },
+  ];
+
+  it("summariseLog carries the explore tag and the plan + build cache-read", () => {
+    const on = summariseLog(slice(1, "on"));
+    assert.deepEqual([on.explore, on.builderCacheRead, on.builderTurns, on.cacheTokens], ["on", 2000, 10, 2130]);
+    assert.equal(summariseLog(slice(1, "off")).explore, "off");
+    assert.equal(summariseLog(slice(1, null)).explore, null);
+    assert.equal(summariseLog(slice(1, "maybe")).explore, null);
+  });
+
+  it("readLocalLaneRuns keeps every RUN_START slice of a log", () => {
+    const dir = tmpDir("explore-ab-");
+    try {
+      writeFileSync(join(dir, "o__r__7.jsonl"), [...slice(7, "on"), ...slice(7, "off", { reason: "needs-human" })].map((e) => JSON.stringify(e)).join("\n"));
+      const runs = readLocalLaneRuns(dir);
+      assert.deepEqual(runs.map((r) => [r.issue, r.explore, r.reason]), [[7, "on", "merged"], [7, "off", "needs-human"]]);
+      assert.equal(readLocalRuns(dir).length, 1);
+      assert.deepEqual(readLocalLaneRuns(join(dir, "missing")), []);
+    } finally { rmSync(dir, { recursive: true, force: true }); }
+  });
+
+  it("reports per size and mode, pairs same issues and leaves untagged runs out", () => {
+    const runs = [slice(1, "on", { size: "L", turns: 3, cr: 500 }), slice(1, "off", { size: "L", turns: 10, cr: 4000 }),
+      slice(2, "on", { size: "L", turns: 4, cr: 600, triggers: ["plan", "build", "conformance"] }), slice(3, "off", { size: "S", reason: "needs-human", review: false }),
+      slice(4, null), slice(5, "on", { size: null })].map((l) => summariseLog(l));
+    const ab = exploreAb(runs);
+    assert.deepEqual(Object.keys(ab.by_size), ["S", "M", "L", "unsized"]);
+    assert.deepEqual(ab.by_size.L.on, { n: 2, builder_turns: 9, builder_cache_read: 1400, merge_rate: 1, conformance_rate: 0.5, reviewed: 2 });
+    assert.deepEqual(ab.by_size.L.off, { n: 1, builder_turns: 20, builder_cache_read: 8000, merge_rate: 1, conformance_rate: 1, reviewed: 1 });
+    assert.deepEqual([ab.by_size.S.off.merge_rate, ab.by_size.S.off.conformance_rate, ab.by_size.M.on.n, ab.by_size.M.on.builder_turns], [0, null, 0, null]);
+    assert.equal(ab.by_size.unsized.on.n, 1);
+    assert.equal(ab.untagged, 1);
+    assert.equal(ab.paired.issues, 1);
+    assert.deepEqual([ab.paired.on.n, ab.paired.on.builder_cache_read, ab.paired.off.n, ab.paired.off.builder_cache_read], [1, 1000, 1, 8000]);
+    const md = renderExploreAb(ab);
+    assert.match(md, /\| L \| on \| 2 \| 9 \| 1400 \| 1 \| 0\.5 \(2\) \|/);
+    assert.match(md, /\| paired \| off \| 1 \| 20 \| 8000 \| 1 \| 1 \(1\) \|/);
+    assert.match(md, /Same issues in both modes: 1/);
+    assert.match(md, /1 finished run\(s\) without an explore tag/);
+  });
+
+  it("--explore-ab reads run logs only (no GitHub crawl)", async () => {
+    assert.equal(parseArgs(["--explore-ab"]).exploreAb, true);
+    assert.equal(parseArgs([]).exploreAb, false);
+    const rep = await buildReport({ repo: "o/r", exploreAb: true }, { localRuns: [summariseLog(slice(1, "on")), { ...summariseLog(slice(2, "on")), repo: "x/y" }], releaseTimes: [], gh: async () => { throw new Error("no network"); } });
+    assert.equal(rep.query.explore_ab.by_size.M.on.n, 1);
+    assert.equal(rep.sources.local.runs, 1);
+  });
+});
+
+describe("context-pack A/B per merge, rework and recovery vs first (#4444)", () => {
+  const use = (trigger, turns, cr, out) => ({ event: "PHASE_ATTEMPT_USAGE", phase: "implement", trigger, turns, cost_usd: 0.5, usage: { cache_read_input_tokens: cr, cache_creation_input_tokens: 10, output_tokens: out } });
+  const slice = (issue, lt, { reason = "merged", mode = "on", ab = false, calls = [["plan", 2, 100, 10], ["build", 10, 1000, 400]], extra = [] } = {}) => [
+    { event: "RUN_START", issue, repo: "o/r", run: `r${issue}${lt}`, ts: lt === "rerun" ? "2026-10-02T00:00:00Z" : "2026-10-01T00:00:00Z" },
+    ...calls.map((c) => use(...c)), ...extra,
+    { event: "RUN_TERMINAL", reason, code: "x", context_pack: mode, lane_type: lt, ...(ab ? { context_ab: true } : {}) },
+  ];
+
+  it("summariseLog: cache-read alone, the implement attempt without the plan call, the ab tag and the log's first-run baseline", () => {
+    const s = summariseLog([...slice(5, "first"), ...slice(5, "rerun", { ab: true, calls: [["recover", 3, 50, 100]] })]);
+    assert.equal(s.cacheReadTokens, 50);
+    assert.deepEqual(s.implementAttempt, { turns: 3, output_tokens: 100 });
+    assert.deepEqual(s.firstRunAttempt, { turns: 10, output_tokens: 400 });
+    assert.equal(s.contextPack.ab, true);
+    assert.equal(summariseLog(slice(5, "first")).firstRunAttempt, null);
+    assert.deepEqual(summariseLog(slice(6, "first", { calls: [] })).implementAttempt, null);
+  });
+
+  it("per-merge turns and cache-read, rework rate and the same-issue recovery ratio", () => {
+    const runs = [summariseLog(slice(1, "first")), summariseLog(slice(2, "first", { reason: "needs-human" })),
+      summariseLog(slice(3, "first", { extra: [{ event: "PHASE_COMMIT", phase: "remediate" }] })),
+      summariseLog([...slice(4, "first"), ...slice(4, "rerun", { calls: [["recover", 5, 0, 100]] })]),
+      summariseLog(slice(1, "rerun", { calls: [["recover", 2, 0, 200]] }))];
+    const ab = contextPackAb(runs);
+    // three runs: 12 builder turns each, 1100 cache-read each, two merged
+    assert.deepEqual([ab.first.on.merged, ab.first.on.turns_per_merge, ab.first.on.cache_read_per_merge, ab.first.on.rework_rate], [2, 18, 1650, 0.3333]);
+    assert.equal(ab.rerun.on.rework_rate, 1);
+    assert.equal(ab.child.on.turns_per_merge, null);
+    // issue 4: 5/10 turns, 100/400 output (own log); issue 1: 2/10 turns, 200/400 output (earlier first run in `runs`)
+    assert.deepEqual(ab.recovery, { pairs: 2, mean_turn_ratio: 0.35, mean_output_ratio: 0.375 });
+    const md = renderContextAb(ab);
+    assert.match(md, /\| Merged \| Turns\/merge \| Cache-read\/merge \| Rework rate \|/);
+    assert.match(md, /\| first \| on \| 3 \| .* \| 2 \| 18 \| 1650 \| 0\.3333 \|/);
+    assert.match(md, /Recovery vs first run \(same issue\): 2 pair\(s\), implement turns ratio 0\.35, output tokens ratio 0\.375/);
+    assert.deepEqual(contextPackAb([]).recovery, { pairs: 0, mean_turn_ratio: null, mean_output_ratio: null });
+  });
+});
+
 describe("builder model tiers over run logs (forge#4394)", () => {
   const use = (phase, trigger, usd = 1) => ({ event: "PHASE_ATTEMPT_USAGE", phase, trigger, cost_usd: usd, usage: { cache_read_input_tokens: 1, output_tokens: 1 } });
   const slice = (issue, { tier = "mid", cls = "small", escalated = false, reason = "merged", triggers = ["plan", "build"], review = true, shadow } = {}) => [
@@ -610,6 +704,71 @@ describe("builder model tiers over run logs (forge#4394)", () => {
   });
 });
 
+describe("lane profile report (#4436)", () => {
+  const use = (phase, profile, baseline, trigger = "build") => ({ event: "PHASE_ATTEMPT_USAGE", phase, trigger, cost_usd: 1, usage: { cache_read_input_tokens: 1, output_tokens: 1 },
+    ...(profile ? { lane_profile: profile } : {}), ...(baseline != null ? { baseline_tokens: baseline } : {}) });
+  const slice = (issue, profile, { impl = [40000], review = 20000, shadow, triggers } = {}) => [
+    { event: "RUN_START", issue, repo: "o/r", run: `r${issue}${profile}` },
+    ...impl.map((b, i) => use("implement", profile, b, triggers?.[i])), ...(review != null ? [use("review", profile, review, "review")] : []),
+    { event: "RUN_TERMINAL", reason: "merged", ...(shadow ? { shadow_would: shadow } : {}) },
+  ];
+
+  it("summariseLog keeps the slice's lane profile and per-phase baselines; resumed sessions add none", () => {
+    const s = summariseLog(slice(1, "lane", { impl: [30000, null] }));
+    assert.equal(s.laneProfile, "lane");
+    assert.deepEqual(s.baselines, { implement: [30000], review: [20000] });
+    const mixed = summariseLog([{ event: "RUN_START", issue: 2 }, use("implement", "memory-off", 1), use("review", "lane", 2), { event: "RUN_TERMINAL", reason: "merged" }]);
+    assert.equal(mixed.laneProfile, "mixed");
+    const old = summariseLog([{ event: "RUN_START", issue: 3 }, use("implement", null, null), { event: "RUN_TERMINAL", reason: "merged" }]);
+    assert.equal(old.laneProfile, null); assert.deepEqual(old.baselines, {});
+  });
+
+  it("readLocalRuns keeps one summary per log by default and every RUN_START slice with allSlices", () => {
+    const dir = tmpDir("lane-profile-");
+    try {
+      writeFileSync(join(dir, "7.jsonl"), [...slice(7, "memory-off", { impl: [60000] }), ...slice(7, "lane", { impl: [25000] })].map((e) => JSON.stringify(e)).join("\n"));
+      const last = readLocalRuns(dir);
+      assert.equal(last.length, 1); assert.equal(last[0].laneProfile, "lane");
+      const all = readLocalRuns(dir, { allSlices: true });
+      assert.deepEqual(all.map((r) => [r.issue, r.laneProfile, r.baselines.implement[0]]), [[7, "memory-off", 60000], [7, "lane", 25000]]);
+    } finally { rmSync(dir, { recursive: true, force: true }); }
+  });
+
+  it("compares baseline and conformance per profile on a pinned issue set", () => {
+    const runs = [
+      slice(1, "memory-off", { impl: [60000, 70000] }), slice(2, "memory-off", { impl: [50000], shadow: "conformance.scope" }),
+      slice(1, "lane", { impl: [20000, 30000], review: 10000 }), slice(2, "lane", { impl: [24000], review: 12000, triggers: ["conformance"] }),
+      slice(3, "lane", { impl: [99999] }), [{ event: "RUN_START", issue: 4 }, use("implement", null, null), { event: "RUN_TERMINAL", reason: "merged" }],
+      [{ event: "RUN_START", issue: 5 }, use("implement", "lane", 1)], // unfinished: left out
+    ].map((l) => summariseLog(l));
+    const all = laneProfileReport(runs);
+    assert.deepEqual(all.profiles.map((p) => [p.profile, p.n]), [["memory-off", 2], ["lane", 3], ["unknown", 1]]);
+    assert.deepEqual(all.issues_in_all, []);
+    const rep = laneProfileReport(runs, { issues: [1, 2] });
+    assert.deepEqual(rep.profiles.map((p) => p.profile), ["memory-off", "lane"]);
+    const [before, after] = rep.profiles;
+    assert.deepEqual(before.phases, [{ phase: "implement", sessions: 3, median: 60000, mean: 60000 }, { phase: "review", sessions: 2, median: 20000, mean: 20000 }]);
+    assert.deepEqual(after.phases[0], { phase: "implement", sessions: 3, median: 24000, mean: 24667 });
+    assert.deepEqual([before.reviewed, before.conformance_rate, before.shadow_blocks], [2, 0.5, 1]);
+    assert.deepEqual([after.reviewed, after.conformance_rate, after.shadow_blocks], [2, 0.5, 0]);
+    assert.deepEqual(rep.issues_in_all, [1, 2]);
+    const md = renderLaneProfiles(rep);
+    assert.match(md, /\| lane \| implement \| 3 \| 24000 \| 24667 \|/);
+    assert.match(md, /\| memory-off \| 2 \| 0\.5 \(2\) \| 1 \|/);
+    assert.match(md, /every profile: #1, #2/);
+    assert.match(renderLaneProfiles(laneProfileReport([])), /\| none \|/);
+  });
+
+  it("--lane-profile reads run logs only (no GitHub crawl); --issues takes a comma list", async () => {
+    assert.equal(parseArgs(["--lane-profile"]).laneProfile, true); assert.equal(parseArgs([]).laneProfile, false);
+    assert.deepEqual(parseArgs(["--issues", "4,12"]).issues, [4, 12]); assert.deepEqual(parseArgs(["--issues=7"]).issues, [7]);
+    assert.throws(() => parseArgs(["--issues", "4,x"]), /--issues must be a comma list/);
+    const rep = await buildReport({ repo: "o/r", laneProfile: true, issues: [1] }, { localRuns: [summariseLog(slice(1, "lane")), summariseLog(slice(2, "lane"))],
+      releaseTimes: [], gh: async () => { throw new Error("no network"); } });
+    assert.deepEqual(rep.query.lane_profile.profiles.map((p) => [p.profile, p.n]), [["lane", 1]]);
+  });
+});
+
 describe("rework by trigger and first-pass rate (#4362)", () => {
   const use = (attempt, trigger, usd, phase = "implement") => ({ event: "PHASE_ATTEMPT_USAGE", phase, attempt, ...(trigger ? { trigger } : {}), cost_usd: usd, usage: { cache_read_input_tokens: 10, output_tokens: 1 } });
   const log = (issue, attempts) => [{ event: "RUN_START", issue, repo: "o/r", run: `r${issue}`, version: "1.30.0", ts: "2026-10-20T00:00:00Z" }, ...attempts,
@@ -783,3 +942,20 @@ describe("fail-soft alerts (#4354)", () => {
     assert.equal(computeAlerts(localLanes, { repo: "o/r" }).length, 1);
   });
 });
+
+describe("env.tool_missing per release (forge#4414)", () => {
+  // The #4393 replay criterion is read as outcome-code counts per engine version; pin that the report surfaces them.
+  const run = (issue, version, reason, code) => ({ issue, repo: "o/r", version, reason, code, finished: true, usageEvents: 1, endTs: "2026-10-23T10:00:00Z", phases: { implement: { cr: 1, out: 1, ms: 1 } } });
+  const runs = [run(1, "1.30.0", "needs-human", "env.tool_missing"), run(2, "1.30.0", "merged", "completed"),
+    run(3, "1.31.0", "merged", "completed"), run(4, "1.31.0", "needs-human", "dependency.open")];
+  const codesOf = (g) => Object.fromEntries(g.flow.codes.map((c) => [c.code, c.count]));
+
+  it("counts env.tool_missing per version and drops pre-release lanes with sinceVersion", () => {
+    const all = aggregate({ runs }, { releaseTimes: [] });
+    assert.equal(codesOf(all.groups.find((g) => g.version === "1.30.0"))["env.tool_missing"], 1);
+    const after = aggregate({ runs }, { releaseTimes: [], sinceVersion: "1.31.0" });
+    assert.deepEqual(after.groups.map((g) => g.version), ["1.31.0"]);
+    assert.equal(codesOf(after.groups[0])["env.tool_missing"], undefined);
+    assert.equal(after.groups[0].flow.codesN, 2);
+  });
+});