forgedock 1.30.0 → 1.32.0

package/bin/stats/local-source.mjs

@@ -21,6 +21,8 @@ function parseLog(text) {
 }
 
 const n = (x) => (Number.isFinite(x) ? x : 0);
+/** #4407: an attempt's own cost; `cost_usd` is a running total for a resumed session, so the delta wins when present. */
+const costOf = (e) => (Number.isFinite(e.cost_usd_delta) ? e.cost_usd_delta : e.cost_usd);
 
 /** Summarise one log: the last RUN_START..end slice. Returns null when there is no RUN_START. */
 export function summariseLog(events, fallbackIssue = null) {
@@ -47,7 +49,7 @@ export function summariseLog(events, fallbackIssue = null) {
     p.out += n(e.usage.output_tokens);
     p.attempts++;
     if (attempt && Number.isFinite(e.duration_ms)) p.ms = (p.ms ?? 0) + e.duration_ms;
-    if (attempt && Number.isFinite(e.cost_usd)) p.usd = (p.usd ?? 0) + e.cost_usd;
+    if (attempt && Number.isFinite(costOf(e))) p.usd = (p.usd ?? 0) + costOf(e);
   }
   const finished = t >= 0 && (r < 0 || t > r);
   // forge#4275: the context-pack A/B inputs. Builder calls log as phase "implement" (the plan call is the first).
@@ -56,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 ?? "");
@@ -68,25 +70,160 @@ export function summariseLog(events, fallbackIssue = null) {
     startTs, endTs, wallMs: finished && !Number.isNaN(a) && !Number.isNaN(b) ? Math.max(0, b - a) : null,
     phases,
     contextPack,
+    // #4362: builder attempts in log order with their trigger (null before the field existed)
+    builderAttempts: builderCalls.map((e) => ({ attempt: e.attempt ?? null, trigger: e.trigger ?? null, restart_of: e.restart_of ?? null, cost_usd: Number.isFinite(costOf(e)) ? costOf(e) : null })),
+    // #4375: pitfalls in the pack matching the issue's files (RUN_TERMINAL, else the last CONTEXT_PACK); null before the field
+    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(e.cost_usd), 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
+    builderRoute: routeOf(term, ev),
+    conformanceRound: builderCalls.some((e) => e.trigger === "conformance" || e.trigger === "review"),
+    shadowWould: typeof term?.shadow_would === "string" ? term.shadow_would : null,
+    reachedReview: reviewCalls > 0 || typeof term?.shadow_would === "string",
+    // #4394: routes of earlier runs in this log that ended merged: a later run of the same issue is post-merge rework
+    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; }, {}),
   };
 }
 
-/** All run summaries in `dir` (a missing dir or an unreadable log yields nothing, never an error). */
-export function readLocalRuns(dir = runsDir()) {
+/** #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") {
+    return { tier: term.builder_tier, class: term.builder_class ?? null, escalated: term.builder_escalated === true, model: term.builder_model ?? null };
+  }
+  const r = [...ev].reverse().find((e) => e.event === "BUILDER_ROUTE");
+  if (!r) return null;
+  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 = [];
+  let slice = null;
+  const close = () => {
+    if (!slice) return;
+    const term = [...slice].reverse().find((e) => e.event === "RUN_TERMINAL");
+    const rt = term?.reason === "merged" ? routeOf(term, slice) : null;
+    if (rt) out.push(rt);
+  };
+  for (const e of events) {
+    if (e.event === "RUN_START") { close(); slice = []; }
+    if (slice) slice.push(e);
+  }
+  close();
+  return out;
+}
+
+/**
+ * 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);
-      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 m = /(?:^|__)(\d+)\.jsonl$/.exec(f); // #4432: `<issue>.jsonl` or `<owner>__<repo>__<issue>.jsonl`
+      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.
+ */
+export function lanesOfLog(events, fallbackIssue = null, fallbackTs = null) {
+  const lanes = [];
+  let cur = null;
+  for (const e of events) {
+    if (e.event === "RUN_START") {
+      cur = { repo: e.repo ?? null, issue: e.issue ?? fallbackIssue, startTs: e.ts ?? fallbackTs, code: null, reason: null,
+        deps: [], toolchainWarnings: [], deferred: [], sparseFallback: null };
+      lanes.push(cur);
+      continue;
+    }
+    if (!cur) continue;
+    if (e.event === "RUN_TERMINAL") { cur.code = e.code ?? null; cur.reason = e.reason ?? null; }
+    else if (e.event === "DEPS_PREPARED") cur.deps.push({ eco: e.eco ?? null, status: e.status ?? null, reason: e.reason ?? null });
+    else if (e.event === "TOOLCHAIN_WARNING" && e.warning) cur.toolchainWarnings.push(String(e.warning));
+    else if (e.event === "PRECHECK_COMMANDS" && Array.isArray(e.results)) {
+      for (const r of e.results) if (r?.status === "deferred-to-ci") cur.deferred.push(String(r.command ?? ""));
+    } else if (e.event === "WORKTREE_SPARSE_FALLBACK") cur.sparseFallback = e.reason ?? "";
+  }
+  return lanes;
+}
+
+/** All lanes in `dir` (a missing dir or an unreadable log yields nothing, never an error). Local files only, no network. */
+export function readLanes(dir = runsDir()) {
+  if (!existsSync(dir)) return [];
+  const lanes = [];
+  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 mtime = new Date(statSync(join(dir, f)).mtimeMs).toISOString();
+      lanes.push(...lanesOfLog(parseLog(readFileSync(join(dir, f), "utf8")), m ? Number(m[1]) : null, mtime));
+    } catch { /* unreadable log */ }
+  }
+  return lanes;
+}

package/bin/stats/query.mjs

@@ -85,15 +85,193 @@ 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}`;
+}
+
+/**
+ * forge#4394: builder model tiers over local run summaries (local-source.mjs summariseLog): tier mid, mid->top
+ * (escalated) or top, each with its routing class. merge_rate: merged / finished. conformance_rate: of the lanes that
+ * reached review, those with no conformance/review fix round and no shadow would-block. post_merge_rework_rate: merges
+ * reworked later (a later run of the same issue, or a remediate phase) / merges, where a log's earlier merged runs count
+ * as merges too. Runs without a route (older logs, refactor:split) are counted under `unrouted` only.
+ */
+export const BUILDER_TIERS = Object.freeze(["mid", "mid->top", "top"]);
+export function builderTierReport(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 tierOf = (rt) => (rt?.tier === "mid" ? (rt.escalated ? "mid->top" : "mid") : rt?.tier === "top" ? "top" : null);
+  const groups = new Map();
+  const group = (tier, cls) => {
+    const k = `${tier}\u0000${cls}`;
+    if (!groups.has(k)) groups.set(k, { tier, class: cls, n: 0, merged: 0, reviewed: 0, conforming: 0, merges: 0, reworked: 0, firstPass: 0, cost: [] });
+    return groups.get(k);
+  };
+  let unrouted = 0;
+  for (const r of runs ?? []) {
+    for (const m of Array.isArray(r?.reworkedMerges) ? r.reworkedMerges : []) {
+      const t = tierOf(m);
+      if (t) { const g = group(t, m.class ?? "unknown"); g.merges++; g.reworked++; }
+    }
+    if (!r?.finished) continue;
+    const t = tierOf(r.builderRoute);
+    if (!t) { unrouted++; continue; }
+    const g = group(t, r.builderRoute.class ?? "unknown");
+    g.n++;
+    g.cost.push(Number.isFinite(r.costUsd) ? r.costUsd : 0);
+    if (r.firstPass) g.firstPass++;
+    if (r.reason === "merged") { g.merged++; g.merges++; if (r.remediated) g.reworked++; }
+    if (r.reachedReview) { g.reviewed++; if (!r.conformanceRound && (r.shadowWould == null || r.shadowWould === "conforms")) g.conforming++; }
+  }
+  const rows = [...groups.values()]
+    .sort((a, b) => BUILDER_TIERS.indexOf(a.tier) - BUILDER_TIERS.indexOf(b.tier) || a.class.localeCompare(b.class))
+    .map((g) => ({ tier: g.tier, class: g.class, n: g.n, merge_rate: rate(g.merged, g.n), conformance_rate: rate(g.conforming, g.reviewed), reviewed: g.reviewed,
+      post_merge_rework_rate: rate(g.reworked, g.merges), merges: g.merges, first_pass_yield: rate(g.firstPass, g.n), cost_usd: mean(g.cost) }));
+  return { rows, unrouted };
+}
+
+/** Markdown table for builderTierReport. */
+export function renderTiers(rep) {
+  const f = (v) => (v == null ? "n/a" : String(v));
+  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/render.mjs

@@ -41,7 +41,16 @@ function sections(g) {
   out.push("### Flow", ...table(["metric", "value"], [
     ["merged", pct(f.mergedPct)], ["needs-human", pct(f.needsHumanPct)], ["remediation rate", pct(f.remediationPct)],
     ["top outcome codes (n=" + f.codesN + ")", f.codes.slice(0, 5).map((x) => `${x.code} ${x.count} (${pct(x.pct)})`).join(", ") || NA],
+    ...(g.firstPass ? [["first-pass rate", `${pct(g.firstPass.rate)} (${g.firstPass.firstPass}/${g.firstPass.n} lanes that reached the build, ${g.firstPass.unknown} unknown)`]] : []),
+    // #4375: the same rate split by whether the context pack carried pitfalls matching the issue's files
+    ...(g.firstPassByPitfalls && (g.firstPassByPitfalls.with.n || g.firstPassByPitfalls.without.n)
+      ? [["with", "without"].map((k) => [`first-pass ${k} matching pitfalls`, `${pct(g.firstPassByPitfalls[k].rate)} (${g.firstPassByPitfalls[k].firstPass}/${g.firstPassByPitfalls[k].n})`])].flat() : []),
   ]), "");
+  if (g.rework) { // #4362: builder rework rounds by trigger; untagged (older) attempts are "unknown"
+    const w = g.rework, rows = Object.entries(w.byTrigger).sort((a, b) => b[1].usd - a[1].usd || a[0].localeCompare(b[0]));
+    out.push("### Rework by trigger", ...(rows.length ? table(["trigger", "count", "cost"], [...rows.map(([t, d]) => [t, String(d.n), usd(d.usd)]), ["total", String(w.n), usd(w.usd)]])
+      : ["No rework attempts."]), "");
+  }
   const r = g.funnel;
   const sev = Object.entries(r.bySeverity).map(([s, d]) => [s, String(d.total), f1(d.perReview), String(d.ISSUE), String(d.NOTE), String(d.INPR_FIX)]);
   out.push("### Review funnel", `${r.reviews} reviews, ${r.findings} findings (${f1(r.perReview)} per review). Validated issues: ${r.validated}, false positives: ${r.falsePositive}.`, "",
@@ -68,6 +77,7 @@ export function renderMarkdown(report) {
   const out = ["# ForgeDock stats", ""];
   if (!report.groups.length) out.push("No data: no finished runs, telemetry records or issues were found.", "");
   for (const g of report.groups) out.push(...sections(g));
+  if (report.alerts?.length) out.push("## ALERTS", "", ...renderAlerts(report.alerts).map((l) => `- ${l}`), "");
   const e = report.excluded;
   out.push(`Finished runs only. Excluded: ${e.unfinished} unfinished, ${e.noUsage} without usage data (hydrated or empty). "~" = version estimated from release times; "unknown" = no version available. Groups with n < ${report.minN} are flagged low-n.`);
   return out.join("\n");
@@ -80,3 +90,15 @@ export function renderCompact(report) {
     pct(g.flow.remediationPct), dur(g.time.wall.p50), f1(g.funnel.perReview), pct(g.gates.acceptance.rate), g.delta ? signed(g.delta.cacheReadMean, k) : NA, g.lowN ? `low-n (<${g.minN})` : "ok"]);
   return table(["Version", "Repo", "n", "Cache-read/issue", "Merged", "Needs-human", "Remediated", "Wall p50", "Findings/review", "Acceptance block", "Delta tokens", "Confidence"], rows).join("\n");
 }
+
+/**
+ * forge#4354: one line per fail-soft alert: event, rate, count/sample lanes, threshold and one example reason. Outcome-code
+ * alerts carry the previous-window share and a factor threshold instead of a percentage.
+ */
+export function renderAlerts(alerts) {
+  return (alerts ?? []).map((a) => {
+    const limit = isNum(a.prevRate) ? `previous window ${pct(a.prevRate)}, threshold ${a.threshold}x` : `threshold ${pct(a.threshold)}`;
+    const ex = a.example ? `, e.g. ${JSON.stringify(String(a.example).slice(0, 200))}` : "";
+    return `${a.event}: ${pct(a.rate)} (${a.count}/${a.sample} lanes, ${limit})${ex}`;
+  });
+}