@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/dist/commands/lane-measure-cli.js

@@ -0,0 +1,1797 @@
+#!/usr/bin/env tsx
+import {
+  lane_cut_stats
+} from "./chunk-LZNYHWRO.js";
+import {
+  lane_why,
+  lane_why_causes
+} from "./chunk-D4HNS43Q.js";
+import {
+  lane_hand_back_held,
+  run_ship_pre_detach
+} from "./chunk-OTZJXU2R.js";
+import {
+  lane_implement_signals
+} from "./chunk-TS4ZK46L.js";
+import "./chunk-BJA5U4Q7.js";
+import {
+  lane_value_missing
+} from "./chunk-AJWR7D3H.js";
+import {
+  lane_held_stats
+} from "./chunk-KQWSENCT.js";
+import {
+  lane_limit_history
+} from "./chunk-2VLHFILE.js";
+import {
+  lane_breakdown_text,
+  lane_check_stats,
+  lane_ci_path_stats
+} from "./chunk-CYQ3ZF7R.js";
+import {
+  split_resolution
+} from "./chunk-DRCTDVI2.js";
+import "./chunk-LWAXXZPS.js";
+import {
+  lane_stats_request
+} from "./chunk-73EBNBUW.js";
+import {
+  lane_sinks,
+  lane_sinks_issues
+} from "./chunk-EK2Y6B4X.js";
+import "./chunk-DXZW4V7J.js";
+import {
+  lane_breakdown_implement,
+  lane_implement_stats,
+  lane_paused_spans,
+  lane_transcript_stats
+} from "./chunk-JGTLNFFE.js";
+import {
+  lane_breakdown,
+  lane_yield_split
+} from "./chunk-VZCQZFPH.js";
+import "./chunk-TXXYC7EV.js";
+import "./chunk-ZAAHZY2A.js";
+import {
+  lane_net_read
+} from "./chunk-VZSJCFRT.js";
+import "./chunk-YPNTORQD.js";
+import {
+  lane_ledger_archive
+} from "./chunk-JOARHU3M.js";
+import "./chunk-6NGNMIMT.js";
+import "./chunk-7ZECP3J6.js";
+import "./chunk-2IESYBZH.js";
+import "./chunk-5PAEXYIY.js";
+import {
+  lane_stage_budget
+} from "./chunk-RQRLW4XK.js";
+import {
+  lane_implement_rate,
+  lane_size_stats
+} from "./chunk-TPKFVVJQ.js";
+import {
+  lane_net_time,
+  lane_stop_stats
+} from "./chunk-EKCKCX5S.js";
+import "./chunk-LUMCYDGE.js";
+import "./chunk-EH3LVYOX.js";
+import {
+  lane_stage_stats
+} from "./chunk-HOSZITJM.js";
+import "./chunk-ESQEEL4O.js";
+import "./chunk-VD5674LW.js";
+import "./chunk-2FJJYCBD.js";
+import "./chunk-BY3POLIQ.js";
+import "./chunk-GU5ML3Y3.js";
+import "./chunk-4Z5723GA.js";
+import "./chunk-HBNB3TLG.js";
+import "./chunk-BJKEXXY6.js";
+import "./chunk-KUJQWO6M.js";
+import "./chunk-6I2JM5UX.js";
+import "./chunk-GPMSYXYO.js";
+import "./chunk-E2ZCUKHT.js";
+import "./chunk-WVR4RUFP.js";
+import "./chunk-5GBZ43UA.js";
+import "./chunk-O5FVBIRI.js";
+import "./chunk-SV4FHQE7.js";
+import "./chunk-6SKMZGER.js";
+import "./chunk-LCEJXF7A.js";
+import "./chunk-HE5S4XRE.js";
+import "./chunk-ENLWXAHD.js";
+import "./chunk-NOXLKIPR.js";
+import "./chunk-E3CXOVPQ.js";
+import "./chunk-GA6E4VGO.js";
+import "./chunk-7EAMUVIO.js";
+import {
+  run_ship_lap
+} from "./chunk-PE7B7242.js";
+import "./chunk-WG6GYBRJ.js";
+import "./chunk-CRNPPKP2.js";
+import "./chunk-LAKVPOJQ.js";
+import {
+  metrics_totals
+} from "./chunk-UU6GCJGM.js";
+import "./chunk-W4J6YTFE.js";
+import "./chunk-BK6Q4VCA.js";
+import "./chunk-P6RGQXHI.js";
+import "./chunk-KB3OQWDT.js";
+import "./chunk-FGL6DBZU.js";
+import {
+  since_green
+} from "./chunk-SNO7CY2B.js";
+import "./chunk-RUIBQMOV.js";
+import "./chunk-OZZWRJQI.js";
+import "./chunk-L6LU2633.js";
+import "./chunk-IXX4SXIP.js";
+import "./chunk-CGLLAEKZ.js";
+import "./chunk-WL5JHB3I.js";
+import "./chunk-4BEIYKI2.js";
+import "./chunk-LE2T3FGJ.js";
+import "./chunk-LQXFVZTS.js";
+import "./chunk-F2HFWLQR.js";
+import "./chunk-WN7NK3NY.js";
+import "./chunk-6NV2F7QH.js";
+import "./chunk-REMKUFAC.js";
+import "./chunk-VGHSZLYQ.js";
+import "./chunk-7LJQMM2K.js";
+import "./chunk-FROACLVU.js";
+import "./chunk-MGF64OHV.js";
+import "./chunk-RK4HE5NW.js";
+import "./chunk-O26Y2FOJ.js";
+import "./chunk-XH6BGVVP.js";
+import "./chunk-RXAZJMSZ.js";
+import "./chunk-3PEXBHRN.js";
+import "./chunk-RZ4OKKPM.js";
+import "./chunk-PBOS7MTW.js";
+import "./chunk-2NSB5ZYQ.js";
+import "./chunk-2MJ4OCDL.js";
+import "./chunk-IW6NWCSN.js";
+import "./chunk-UCI4AL3Q.js";
+import {
+  lane_sampler,
+  lane_stats,
+  lane_tail_stats
+} from "./chunk-QS5USD4T.js";
+import "./chunk-WWC5L3AO.js";
+import {
+  lane_ledger
+} from "./chunk-XYAK53TK.js";
+import {
+  run_event_setup
+} from "./chunk-BNXE3NVB.js";
+import "./chunk-E33LSO2W.js";
+import "./chunk-Y2RNUX4W.js";
+import "./chunk-F22G3VDB.js";
+import "./chunk-W4YH2DF3.js";
+import "./chunk-LHKXJD6L.js";
+import "./chunk-ROJXMBXP.js";
+import "./chunk-FCINBCKB.js";
+import "./chunk-Q5Q2QYVU.js";
+import "./chunk-GO3GH7FG.js";
+import "./chunk-KVHNQHX3.js";
+import "./chunk-7HCPRVMB.js";
+import "./chunk-RUWV4INF.js";
+import "./chunk-JTU5A4JI.js";
+import "./chunk-FNQW6NY7.js";
+import "./chunk-DBKTFB5V.js";
+import "./chunk-UCQJDYE3.js";
+import "./chunk-TCBUX52E.js";
+import "./chunk-KXHXMERX.js";
+import "./chunk-MDLOETXL.js";
+import "./chunk-65E4OZJ7.js";
+import "./chunk-NFKULY26.js";
+import "./chunk-LRS2OS5J.js";
+import "./chunk-AI5K4QJO.js";
+import "./chunk-7S6VRZOH.js";
+import "./chunk-LULJUD6P.js";
+import "./chunk-TBNQIFWL.js";
+import "./chunk-P4CWLRT2.js";
+import "./chunk-XFPEUYDV.js";
+import "./chunk-5ZTQX7OS.js";
+import "./chunk-HCA5QG2U.js";
+import "./chunk-C2SEDMZ3.js";
+import "./chunk-LRA3PXHS.js";
+import "./chunk-6OP63TBT.js";
+import "./chunk-TVZXG4Y4.js";
+import "./chunk-FIUCHMCF.js";
+import "./chunk-XXNEY4B3.js";
+import "./chunk-4PUKDAXL.js";
+import "./chunk-EWVR5AEX.js";
+import "./chunk-C6QSVO5K.js";
+import "./chunk-W3FX7FYN.js";
+import "./chunk-ZBFNQUY7.js";
+import "./chunk-U3IVVR4W.js";
+import "./chunk-O3NDWYNT.js";
+import {
+  lane_spans
+} from "./chunk-34LAULSC.js";
+import "./chunk-5Y7QQYTU.js";
+import "./chunk-34DND4BA.js";
+import {
+  run_event_stream
+} from "./chunk-NSAVEXVR.js";
+import "./chunk-P4KIQRSL.js";
+import "./chunk-QQBMVC5W.js";
+import "./chunk-TUIFS5E7.js";
+import "./chunk-QAHFPCFR.js";
+import "./chunk-66TGK5XL.js";
+import {
+  agent_profile_schema
+} from "./chunk-EZSO25UZ.js";
+import "./chunk-2DJLAUYB.js";
+import "./chunk-EW4NPUMQ.js";
+import "./chunk-BF6YX4HE.js";
+import "./chunk-3LZXX5GL.js";
+import "./chunk-W2IA2LV3.js";
+import {
+  run_ship_stage
+} from "./chunk-OHNP3QL2.js";
+import {
+  session_cite
+} from "./chunk-X7PN54LZ.js";
+import "./chunk-MDKDJF2K.js";
+import "./chunk-HQ2HSZBN.js";
+import "./chunk-WQ6FS544.js";
+import "./chunk-6HRRZANN.js";
+import {
+  lane_ledger_kind
+} from "./chunk-I63RNFFR.js";
+import "./chunk-MPGJ4ONJ.js";
+import {
+  cost_transcript
+} from "./chunk-6WKJ3GDA.js";
+import "./chunk-YIA6FC3K.js";
+import "./chunk-JQXPLMCO.js";
+import {
+  issue_number_shape
+} from "./chunk-66NX6EXR.js";
+import "./chunk-3NWAGIA6.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import "./chunk-HLUS2M3D.js";
+import "./chunk-SBGTCT2C.js";
+import "./chunk-AKK56GNX.js";
+import "./chunk-TBIX5FRN.js";
+import "./chunk-IGD6QJPH.js";
+import "./chunk-FFHEGWPK.js";
+import "./chunk-R6QE5VJG.js";
+import "./chunk-4ZHWTTQW.js";
+import "./chunk-RDRN56E4.js";
+import "./chunk-XDF25GSU.js";
+import "./chunk-EBVS2LKX.js";
+import "./chunk-AQ3PMSXK.js";
+import "./chunk-QVOFWFWC.js";
+import "./chunk-G6BXCWPH.js";
+import "./chunk-CDY4NFQG.js";
+import "./chunk-OKYFQJW3.js";
+import "./chunk-HHBC6QZE.js";
+import "./chunk-QWWTC3XR.js";
+import "./chunk-ILGPZ47M.js";
+import "./chunk-3CCGKX7Y.js";
+import "./chunk-KSR23NYN.js";
+import "./chunk-D5TAR6TV.js";
+import "./chunk-V5FD7DVV.js";
+import "./chunk-36LOGVJ7.js";
+import "./chunk-ENFPR7J2.js";
+import "./chunk-F7XLEK55.js";
+import "./chunk-UGCUSRZF.js";
+import "./chunk-AKQYYHP2.js";
+import "./chunk-CJKPF5DJ.js";
+import "./chunk-RBU2NKHF.js";
+import "./chunk-NKKH3PBE.js";
+import "./chunk-B77ZMVHS.js";
+import "./chunk-B5GXZK3E.js";
+import "./chunk-KTLR4Y32.js";
+import "./chunk-ZNX2LJCQ.js";
+import "./chunk-VJE3RJAX.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+import "./chunk-HIU2WXB6.js";
+
+// scripts/lane/lane-measure-cli.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { setInterval as every } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+
+// scripts/lane/lane-over-causes.ts
+import path from "node:path";
+
+// scripts/lane/lane-over.ts
+var COLUMNS = ["lane", "net min", "wait min", "chain", "over budget", "top stage", "open issues"];
+var SEPARATOR = " \xB7 ";
+var NO_CHAIN = "-";
+var GAP_OPEN = "gap open";
+var DISPATCHED_FIRST = "dispatched before holder end";
+var { KIND } = lane_ledger_kind;
+function of_kind(entries, kind, issue) {
+  return entries.filter(
+    (entry) => entry.kind === kind && "issue" in entry && entry.issue === issue
+  );
+}
+function counted(label, count) {
+  return count === 0 ? [] : [`${label} \xD7${String(count)}`];
+}
+function split_part({ entries }, issue) {
+  const children = of_kind(entries, KIND.SPLIT_FILED, issue).map((entry) => entry.child);
+  const filed = children.length === 0 ? [] : [`${KIND.SPLIT_FILED} ${children.join(", ")}`];
+  const notices = of_kind(entries, KIND.SPLIT_NOTICE, issue).length;
+  return [...counted(KIND.SPLIT_NOTICE, notices), ...filed];
+}
+function round_part({ entries }, issue) {
+  const rounds = of_kind(entries, KIND.ROUND_ONE, issue);
+  return rounds.some((round) => round.verdict === "blocking") ? ["round 1 blocking"] : [];
+}
+function unplanned_part({ entries }, issue) {
+  return counted(KIND.UNPLANNED_NOTICE, of_kind(entries, KIND.UNPLANNED_NOTICE, issue).length);
+}
+function gap_text({ gap_ms, is_early }) {
+  if (gap_ms !== void 0) return `gap ${String(Math.round(gap_ms / MS_PER_MINUTE))} min`;
+  return is_early ? DISPATCHED_FIRST : GAP_OPEN;
+}
+function yield_text(taken) {
+  const { holder } = taken;
+  const target = holder === void 0 ? "yield" : `yield \u2192 ${session_cite.issue(holder)}`;
+  return `${target} ${gap_text(taken)}`;
+}
+function yield_part({ entries, events }, issue) {
+  return lane_yield_split.of_issue(entries, events, issue).map((taken) => yield_text(taken));
+}
+function hub_part({ entries }, issue) {
+  return lane_sinks.hubs_of(entries, [issue]).map((hub) => `hub over cap ${hub}`);
+}
+var CHAIN_PARTS = [
+  split_part,
+  round_part,
+  unplanned_part,
+  yield_part,
+  hub_part
+];
+function chain_of(records, issue) {
+  const parts = CHAIN_PARTS.flatMap((part) => part(records, issue));
+  return parts.length === 0 ? NO_CHAIN : parts.join(SEPARATOR);
+}
+function budget_text({ name, ms }) {
+  const budget = lane_breakdown_text.budget_of(name);
+  if (budget === void 0 || lane_stage_budget.over_minutes(budget, ms) === void 0) return [];
+  const minutes = (ms / MS_PER_MINUTE).toFixed(1);
+  return [`${name} ${minutes}/${String(lane_stage_budget.BUDGET_MINUTES[budget])}`];
+}
+function over_budget_of({ entries, events }, issue) {
+  const stages = lane_breakdown_implement.breakdown_of(entries, events, issue)?.stages ?? [];
+  const parts = stages.flatMap((stage) => budget_text(stage));
+  return parts.length === 0 ? NO_CHAIN : parts.join(SEPARATOR);
+}
+function wait_ms(records, issue, net_ms) {
+  const span = lane_net_time.span_of(records.entries, issue);
+  return span === void 0 ? void 0 : span.to_ms - span.from_ms - net_ms;
+}
+function net_of(records, issue) {
+  return lane_net_time.net_ms(records.entries, records.events, issue) ?? 0;
+}
+function lane_row(records, issue, issues) {
+  const net_ms = net_of(records, issue);
+  const [top] = lane_sinks.sinks_of(records, [issue]);
+  const stage = top?.name ?? NO_CHAIN;
+  return lane_stats.to_row([
+    session_cite.issue(issue),
+    lane_stage_stats.cell(net_ms),
+    lane_stage_stats.cell(wait_ms(records, issue, net_ms)),
+    chain_of(records, issue),
+    over_budget_of(records, issue),
+    stage,
+    top === void 0 ? lane_sinks_issues.NONE : lane_sinks.issues_cell(stage, issues, lane_sinks.hubs_of(records.entries, [issue]))
+  ]);
+}
+function table(records, window, minutes, issues) {
+  const lanes = lane_sinks.over_issues(records, window, minutes).toSorted((left, right) => net_of(records, right) - net_of(records, left));
+  return [
+    lane_stats.to_row(COLUMNS),
+    lane_stats.to_row(COLUMNS.map(() => "---")),
+    ...lanes.map((issue) => lane_row(records, issue, issues))
+  ].join("\n");
+}
+var lane_over = { chain_of, over_budget_of, table };
+
+// scripts/lane/lane-over-causes.ts
+var KIND2 = { HUB: "hub", JOB: "ci job" };
+var COLUMNS2 = ["kind", "cause", "lanes", "over min", "open issues"];
+var CANDIDATES = "filing candidates: ";
+var NAME_SEPARATOR = ", ";
+function lane_causes(records, issue) {
+  const hubs = lane_sinks.hubs_of(records.entries, [issue]).map((hub) => ({ kind: KIND2.HUB, key: hub, word: path.basename(hub) }));
+  const jobs = lane_why_causes.keys_of(records.entries, issue, void 0).map((job) => ({ kind: KIND2.JOB, key: job, word: job }));
+  return [...hubs, ...jobs];
+}
+function add_lane(groups, records, issue, threshold_ms) {
+  const over_ms = (lane_net_time.net_ms(records.entries, records.events, issue) ?? 0) - threshold_ms;
+  for (const cause of lane_causes(records, issue)) {
+    const id = `${cause.kind}:${cause.key}`;
+    const group2 = groups.get(id) ?? { ...cause, lanes: /* @__PURE__ */ new Set(), over_ms: 0 };
+    group2.lanes.add(issue);
+    group2.over_ms += over_ms;
+    groups.set(id, group2);
+  }
+}
+function causes_of(records, window, minutes) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const issue of lane_sinks.over_issues(records, window, minutes)) {
+    add_lane(groups, records, issue, minutes * MS_PER_MINUTE);
+  }
+  return [...groups.values()].toSorted((left, right) => right.over_ms - left.over_ms);
+}
+function row_of(cause, issues) {
+  return lane_stats.to_row([
+    cause.kind,
+    cause.key,
+    String(cause.lanes.size),
+    lane_stage_stats.cell(cause.over_ms),
+    lane_why_causes.open_cell([cause.word], issues)
+  ]);
+}
+function candidates_line(causes, issues) {
+  if (issues === void 0) return `${CANDIDATES}${lane_sinks_issues.UNREAD}`;
+  const unfiled = causes.filter((cause) => lane_why_causes.issues_of(cause.word, issues).length === 0).map((cause) => `${cause.kind} ${cause.key}`);
+  return `${CANDIDATES}${unfiled.length === 0 ? lane_sinks_issues.NONE : unfiled.join(NAME_SEPARATOR)}`;
+}
+function table2(records, window, minutes, issues) {
+  const causes = causes_of(records, window, minutes);
+  return [
+    lane_stats.to_row(COLUMNS2),
+    lane_stats.to_row(COLUMNS2.map(() => "---")),
+    ...causes.map((cause) => row_of(cause, issues)),
+    "",
+    candidates_line(causes, issues)
+  ].join("\n");
+}
+function view(records, window, minutes, issues) {
+  return [
+    lane_over.table(records, window, minutes, issues),
+    table2(records, window, minutes, issues)
+  ].join("\n\n");
+}
+var lane_over_causes = { table: table2, view };
+
+// scripts/lane/lane-pairs.ts
+var COLUMNS3 = ["group", "row", "runs", "total min"];
+var NAMED_GROUP = "named files";
+var UNSPLIT_GROUP = "unsplit";
+var HUB_GROUP = "over-cap hub";
+var FEW_FILES = 50;
+var MANY_FILES = 1e3;
+var DETAIL_LEAD = ": ";
+function is_few(named) {
+  return named < FEW_FILES;
+}
+function is_many(named) {
+  return named > MANY_FILES;
+}
+function is_between(named) {
+  return !is_few(named) && !is_many(named);
+}
+var BUCKETS = [
+  { label: `<${String(FEW_FILES)}`, holds: is_few },
+  { label: `${String(FEW_FILES)}-${String(MANY_FILES)}`, holds: is_between },
+  { label: `>${String(MANY_FILES)}`, holds: is_many }
+];
+function is_pair_lap(entry) {
+  return entry.kind === lane_ledger.KIND.SHIP_LAP && entry.step === run_ship_lap.STEP.SCOPED_PAIR;
+}
+function is_capped(entry) {
+  return entry.kind === lane_ledger.KIND.TEST_RELATED && entry.over_cap_hub !== void 0;
+}
+function bucket_of({ named }) {
+  if (named === void 0) return void 0;
+  return BUCKETS.find((bucket) => bucket.holds(named))?.label;
+}
+function reason_of({ unsplit }) {
+  return unsplit?.split(DETAIL_LEAD)[0];
+}
+function hub_of({ over_cap_hub }) {
+  return over_cap_hub;
+}
+function added(was, ms) {
+  return { runs: (was?.runs ?? 0) + 1, ms: (was?.ms ?? 0) + ms };
+}
+function tally(rows, key_of, seed = []) {
+  const tallies = new Map(seed.map((name) => [name, { runs: 0, ms: 0 }]));
+  for (const row of rows) {
+    const key = key_of(row);
+    if (key !== void 0) tallies.set(key, added(tallies.get(key), row.elapsed_ms));
+  }
+  return tallies;
+}
+function ranked(tallies) {
+  return new Map([...tallies].toSorted((left, right) => right[1].ms - left[1].ms));
+}
+function group_rows(group2, tallies) {
+  return [...tallies].map(
+    ([name, { runs, ms }]) => lane_stats.to_row([group2, name, String(runs), lane_stage_stats.cell(ms)])
+  );
+}
+function table3(entries, window) {
+  const period = lane_stats.in_window(entries, window);
+  const laps = period.filter((entry) => is_pair_lap(entry));
+  const capped = period.filter((entry) => is_capped(entry));
+  const labels = BUCKETS.map((bucket) => bucket.label);
+  return [
+    lane_stats.to_row(COLUMNS3),
+    lane_stats.to_row(COLUMNS3.map(() => "---")),
+    ...group_rows(NAMED_GROUP, tally(laps, bucket_of, labels)),
+    ...group_rows(UNSPLIT_GROUP, ranked(tally(laps, reason_of))),
+    ...group_rows(HUB_GROUP, ranked(tally(capped, hub_of)))
+  ].join("\n");
+}
+var lane_pairs = { table: table3 };
+
+// scripts/lane/lane-chain-stop-stats.ts
+var COLUMNS4 = ["stopped at", "stops", "to re-run (min)", "median (min)", "not re-run"];
+var JOIN_SUFFIX = " --join";
+var { NOT_MEASURED, is_number } = lane_stage_stats;
+var NONE_ROW = ["none", "0", NOT_MEASURED, NOT_MEASURED, "0"];
+function is_chain(entry) {
+  return entry.kind === lane_ledger.KIND.CHAIN;
+}
+function started_ms(chain) {
+  return Date.parse(chain.at) - chain.elapsed_ms;
+}
+function wait_ms2(stop, runs) {
+  const stopped_ms = Date.parse(stop.at);
+  const starts = runs.filter((run2) => run2.issue === stop.issue).map((run2) => started_ms(run2)).filter((at) => at >= stopped_ms);
+  return starts.length === 0 ? void 0 : Math.min(...starts) - stopped_ms;
+}
+function cause_of(chain) {
+  if (chain.stage === void 0 || chain.reason === void 0) return void 0;
+  return `${chain.stage}${chain.join ? JOIN_SUFFIX : ""} (${chain.reason})`;
+}
+function stops_of(period, runs) {
+  return period.flatMap((chain) => {
+    const cause = cause_of(chain);
+    return cause === void 0 ? [] : { cause, wait_ms: wait_ms2(chain, runs) };
+  });
+}
+function total(values) {
+  return values.reduce((sum2, value3) => sum2 + value3, 0);
+}
+function waits_of(stops, cause) {
+  return stops.filter((stop) => stop.cause === cause).map((stop) => stop.wait_ms).filter((value3) => is_number(value3));
+}
+function cause_row(cause, stops) {
+  const waits = waits_of(stops, cause);
+  const count = stops.filter((stop) => stop.cause === cause).length;
+  return lane_stats.to_row([
+    cause,
+    String(count),
+    lane_stage_stats.cell(waits.length === 0 ? void 0 : total(waits)),
+    lane_stage_stats.cell(lane_stats.median(waits)),
+    String(count - waits.length)
+  ]);
+}
+function causes_of2(stops) {
+  const causes = [...new Set(stops.map((stop) => stop.cause))];
+  return causes.toSorted(
+    (left, right) => total(waits_of(stops, right)) - total(waits_of(stops, left))
+  );
+}
+function table4(entries, window) {
+  const stops = stops_of(
+    lane_stats.in_window(entries, window).filter(is_chain),
+    entries.filter(is_chain)
+  );
+  const rows = causes_of2(stops).map((cause) => cause_row(cause, stops));
+  return [
+    lane_stats.to_row(COLUMNS4),
+    lane_stats.to_row(COLUMNS4.map(() => "---")),
+    ...rows.length === 0 ? [lane_stats.to_row(NONE_ROW)] : rows
+  ].join("\n");
+}
+var lane_chain_stop_stats = { table: table4 };
+
+// scripts/lane/lane-claim-stats.ts
+var DECIMALS = 1;
+var COLUMNS5 = [
+  "check",
+  "claim",
+  "runs",
+  "cores median",
+  "cores p90",
+  "cores max",
+  "wait (s)"
+];
+var { NOT_MEASURED: NOT_MEASURED2 } = lane_stage_stats;
+function is_gate(entry) {
+  return entry.kind === lane_ledger.KIND.GATE;
+}
+function is_measured(check) {
+  return check.is_reused !== true && check.cpu_ms !== void 0 && check.elapsed_ms > 0;
+}
+function number_cell(value3) {
+  return value3 === void 0 ? NOT_MEASURED2 : value3.toFixed(DECIMALS);
+}
+function seconds_cell(milliseconds) {
+  return number_cell(milliseconds === void 0 ? void 0 : milliseconds / MS_PER_SECOND);
+}
+function total2(values) {
+  return values.reduce((sum2, value3) => sum2 + value3, 0);
+}
+function check_row(label, checks) {
+  const runs = checks.filter((check) => check.label === label);
+  const cores2 = runs.map((check) => check.cpu_ms / check.elapsed_ms);
+  const claims = runs.map((check) => check.claim).filter((claim) => claim !== void 0);
+  const requested = claims.map((claim) => claim.requested);
+  const waited_ms = claims.length === 0 ? void 0 : total2(claims.map((claim) => claim.waited_ms));
+  return lane_stats.to_row([
+    label,
+    number_cell(lane_stats.median(requested)),
+    String(runs.length),
+    number_cell(lane_stats.median(cores2)),
+    number_cell(lane_tail_stats.tail_minutes(cores2)),
+    number_cell(lane_stats.peak(cores2)),
+    seconds_cell(waited_ms)
+  ]);
+}
+function table5(entries, window) {
+  const gates = lane_stats.in_window(entries, window).filter(is_gate);
+  const checks = gates.flatMap((gate) => gate.checks ?? []).filter(is_measured);
+  const labels = [...new Set(checks.map((check) => check.label))];
+  const header = [lane_stats.to_row(COLUMNS5), lane_stats.to_row(COLUMNS5.map(() => "---"))];
+  return [...header, ...labels.map((label) => check_row(label, checks))].join("\n");
+}
+var lane_claim_stats = { table: table5 };
+
+// scripts/lane/lane-concurrency-stats.ts
+var TIMED_COMMANDS = ["lint:related", "test:related"];
+var SAMPLE_MAX_AGE_MINUTES = 5;
+var SAMPLE_MAX_AGE_MS = SAMPLE_MAX_AGE_MINUTES * MS_PER_MINUTE;
+var DECIMALS2 = 1;
+var COLUMNS6 = [
+  "concurrent lanes",
+  ...TIMED_COMMANDS.flatMap((name) => [`${name} runs`, `${name} median (s)`])
+];
+function is_counted(entry) {
+  return entry.kind === lane_ledger.KIND.LOAD && entry.lanes !== void 0;
+}
+function samples_of(entries) {
+  return entries.filter(is_counted).map((entry) => ({ at_ms: Date.parse(entry.at), lanes: entry.lanes })).toSorted((left, right) => left.at_ms - right.at_ms);
+}
+function lanes_at(samples, started_ms2) {
+  const sample = samples.findLast((candidate) => candidate.at_ms <= started_ms2);
+  return sample !== void 0 && started_ms2 - sample.at_ms <= SAMPLE_MAX_AGE_MS ? sample.lanes : void 0;
+}
+function timed_run(name, call, lanes) {
+  if (lanes === void 0 || call.duration_ms === void 0) return [];
+  return [{ name, lanes, ms: call.duration_ms }];
+}
+function timed_runs(calls, samples) {
+  return TIMED_COMMANDS.flatMap(
+    (name) => lane_transcript_stats.solo_calls(calls, name).flatMap((call) => timed_run(name, call, lanes_at(samples, call.started_ms)))
+  );
+}
+function seconds_cell2(values) {
+  const median = lane_stats.median(values);
+  return median === void 0 ? lane_stage_stats.NOT_MEASURED : (median / MS_PER_SECOND).toFixed(DECIMALS2);
+}
+function lane_row2(lanes, runs) {
+  const at_count = runs.filter((run2) => run2.lanes === lanes);
+  const cells = TIMED_COMMANDS.flatMap((name) => {
+    const durations = at_count.filter((run2) => run2.name === name).map((run2) => run2.ms);
+    return [String(durations.length), seconds_cell2(durations)];
+  });
+  return lane_stats.to_row([String(lanes), ...cells]);
+}
+function table6(entries, calls, window) {
+  const runs = timed_runs(lane_transcript_stats.in_period(calls, window), samples_of(entries));
+  const counts = [...new Set(runs.map((run2) => run2.lanes))].toSorted((left, right) => left - right);
+  return [
+    lane_stats.to_row(COLUMNS6),
+    lane_stats.to_row(COLUMNS6.map(() => "---")),
+    ...counts.map((lanes) => lane_row2(lanes, runs))
+  ].join("\n");
+}
+var lane_concurrency_stats = { table: table6 };
+
+// scripts/lane/lane-core-wait-stats.ts
+var COLUMNS7 = ["lane", "total (min)", "median (min)", "waits"];
+var OUTSIDE_A_LANE = "outside a lane";
+var { NOT_MEASURED: NOT_MEASURED3 } = lane_stage_stats;
+var NONE_ROW2 = ["none", NOT_MEASURED3, NOT_MEASURED3, "0"];
+function is_core_wait(entry) {
+  return entry.kind === lane_ledger.KIND.CORE_WAIT;
+}
+function lane_of(wait) {
+  return wait.issue === void 0 ? OUTSIDE_A_LANE : String(wait.issue);
+}
+function total3(values) {
+  return values.reduce((sum2, value3) => sum2 + value3, 0);
+}
+function waits_of2(waits, lane) {
+  return waits.filter((wait) => lane_of(wait) === lane).map((wait) => wait.waited_ms);
+}
+function lane_row3(lane, waits) {
+  const waited = waits_of2(waits, lane);
+  return lane_stats.to_row([
+    lane,
+    lane_stage_stats.cell(total3(waited)),
+    lane_stage_stats.cell(lane_stats.median(waited)),
+    String(waited.length)
+  ]);
+}
+function lanes_of(waits) {
+  const lanes = [...new Set(waits.map((wait) => lane_of(wait)))];
+  return lanes.toSorted(
+    (left, right) => total3(waits_of2(waits, right)) - total3(waits_of2(waits, left))
+  );
+}
+function table7(entries, window) {
+  const waits = lane_stats.in_window(entries, window).filter((entry) => is_core_wait(entry));
+  const rows = lanes_of(waits).map((lane) => lane_row3(lane, waits));
+  return [
+    lane_stats.to_row(COLUMNS7),
+    lane_stats.to_row(COLUMNS7.map(() => "---")),
+    ...rows.length === 0 ? [lane_stats.to_row(NONE_ROW2)] : rows
+  ].join("\n");
+}
+var lane_core_wait_stats = { table: table7 };
+
+// scripts/lane/lane-early-push-stats.ts
+var COLUMNS8 = ["early push", "result", "decisions"];
+function table8(entries, window) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const entry of lane_stats.in_window(entries, window)) {
+    if (entry.kind !== "early-push") continue;
+    const key = lane_stats.to_row([entry.source, entry.result]);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  const rows = [...counts].map(([key, count]) => `${key} ${String(count)} |`);
+  return [lane_stats.to_row(COLUMNS8), lane_stats.to_row(COLUMNS8.map(() => "---")), ...rows].join(
+    "\n"
+  );
+}
+var lane_early_push_stats = { table: table8 };
+
+// scripts/lane/lane-gap-stats.ts
+var COLUMNS9 = ["gap", "count", "median (s)", "max (s)", "not ended"];
+var RELAUNCH = "cut \u2192 resume";
+var OUTAGE = "outage \u2192 relaunch";
+var PARK = "park \u2192 offer";
+var YIELD = "yield \u2192 redispatch";
+var YIELD_PART = {
+  HOLDER: "yield: holder running",
+  OFFER: "yield: offer wait",
+  LAUNCH: "yield: launch",
+  UNKNOWN: "yield: holder unknown"
+};
+var MERGE = "followup \u2192 merge";
+var FIRST_LANE = "start \u2192 first lane";
+var FOLLOWUP_STAGE = "followup";
+var IMPLEMENTATION_CUT = `cut (${agent_profile_schema.IMPLEMENTATION_PHASE})`;
+var { NOT_MEASURED: NOT_MEASURED4, is_dispatch, is_merge, is_number: is_number2, is_stage } = lane_stage_stats;
+var { EVENT_KIND } = run_event_stream;
+var OFFER_ANSWERS = /* @__PURE__ */ new Set([
+  lane_ledger.KIND.HELD,
+  lane_ledger.KIND.RELEASED
+]);
+function implementation_cuts(events) {
+  return events.filter((event) => event.text.endsWith(IMPLEMENTATION_CUT));
+}
+function relaunch_spans(events) {
+  return lane_spans.issue_spans({
+    starts: lane_stop_stats.events_of(implementation_cuts(events), EVENT_KIND.CUT),
+    bounds: lane_stop_stats.events_of(events, EVENT_KIND.CUT),
+    ends: lane_stop_stats.events_of(events, EVENT_KIND.RESUME)
+  });
+}
+function outage_spans(events) {
+  const outages = lane_stop_stats.events_of(events, EVENT_KIND.OUTAGE);
+  return lane_spans.issue_spans({
+    starts: outages,
+    bounds: outages,
+    ends: lane_stop_stats.events_of(events, EVENT_KIND.CHILD_LAUNCH)
+  });
+}
+function is_offer_answer(entry) {
+  if (entry.kind === lane_ledger.KIND.HELD) return !lane_hand_back_held.is_driverless(entry.reason);
+  return is_dispatch(entry) || OFFER_ANSWERS.has(entry.kind);
+}
+function offer_times(entries) {
+  return entries.filter((entry) => is_offer_answer(entry)).map((entry) => Date.parse(entry.at)).toSorted((left, right) => left - right);
+}
+function park_spans(entries, events) {
+  const offers = offer_times(entries);
+  return lane_stop_stats.events_of(events, EVENT_KIND.PARK).map((park) => ({ from_ms: park.at_ms, end_ms: offers.find((at) => at > park.at_ms) }));
+}
+function is_followup_of(entry, merge) {
+  return is_stage(entry) && entry.stage === FOLLOWUP_STAGE && entry.issue === merge.issue && entry.at <= merge.at;
+}
+function merge_span(entries, merge) {
+  const followup = entries.findLast((entry) => is_followup_of(entry, merge));
+  return followup === void 0 ? void 0 : { from_ms: Date.parse(followup.at), end_ms: Date.parse(merge.at) };
+}
+function merge_spans(entries) {
+  return entries.filter((entry) => is_merge(entry)).map((merge) => merge_span(entries, merge)).filter((span) => span !== void 0);
+}
+function seconds(milliseconds) {
+  return milliseconds === void 0 ? NOT_MEASURED4 : String(Math.round(milliseconds / MS_PER_SECOND));
+}
+function is_in(span, window) {
+  return span.from_ms >= window.since_ms && span.from_ms <= window.until_ms;
+}
+function span_row(name, started) {
+  const ended = started.map((span) => span.end_ms === void 0 ? void 0 : span.end_ms - span.from_ms).filter((value3) => is_number2(value3));
+  return lane_stats.to_row([
+    name,
+    String(started.length),
+    seconds(lane_stats.median(ended)),
+    seconds(lane_stats.peak(ended)),
+    String(started.length - ended.length)
+  ]);
+}
+function gap_row(name, spans, window) {
+  return span_row(
+    name,
+    spans.filter((span) => is_in(span, window))
+  );
+}
+function waits_of3(parts) {
+  return parts.map((part) => part.wait);
+}
+function yield_rows(entries, events, window) {
+  const inside = lane_yield_split.parts(entries, events).filter((part) => is_in(part.wait, window));
+  const unknown = inside.filter((part) => part.holder === void 0);
+  return [
+    span_row(YIELD, waits_of3(inside)),
+    span_row(
+      YIELD_PART.HOLDER,
+      inside.flatMap((part) => part.holder ?? [])
+    ),
+    span_row(
+      YIELD_PART.OFFER,
+      inside.flatMap((part) => part.offer ?? [])
+    ),
+    span_row(
+      YIELD_PART.LAUNCH,
+      inside.flatMap((part) => part.launch ?? [])
+    ),
+    span_row(YIELD_PART.UNKNOWN, waits_of3(unknown))
+  ];
+}
+function table9(entries, window, events = []) {
+  return [
+    lane_stats.to_row(COLUMNS9),
+    lane_stats.to_row(COLUMNS9.map(() => "---")),
+    gap_row(RELAUNCH, relaunch_spans(events), window),
+    gap_row(OUTAGE, outage_spans(events), window),
+    gap_row(PARK, park_spans(entries, events), window),
+    ...yield_rows(entries, events, window),
+    gap_row(MERGE, merge_spans(entries), window),
+    gap_row(FIRST_LANE, run_event_setup.first_lane_spans(events), window)
+  ].join("\n");
+}
+var lane_gap_stats = { table: table9 };
+
+// scripts/lane/lane-implement-read.ts
+var READ_STAGE = "read";
+var READ_TOOL = "Read";
+var INVESTIGATOR = "investigator";
+var WORD_BOUNDARY = /[\s`'"()[\]{}<>*,;]+/u;
+var CURRENT_DIRECTORY = "./";
+var LINE_START = /^~?\d/u;
+var FILE_NAME = /\.[a-z]+$/iu;
+var SEPARATOR2 = "/";
+var COLUMNS10 = [
+  "implement read",
+  "lanes",
+  "tool (min)",
+  "thinking (min)",
+  "files read",
+  "investigator-cited"
+];
+function is_investigator(call) {
+  return call.subagent?.type.endsWith(INVESTIGATOR) === true;
+}
+function citation_of(word) {
+  const colon = word.indexOf(":");
+  const cited = word.slice(0, Math.max(0, colon));
+  const path3 = cited.startsWith(CURRENT_DIRECTORY) ? cited.slice(CURRENT_DIRECTORY.length) : cited;
+  return FILE_NAME.test(path3) && LINE_START.test(word.slice(colon + 1)) ? path3 : void 0;
+}
+function cited_paths(calls) {
+  return calls.filter((call) => is_investigator(call)).flatMap((call) => call.output.split(WORD_BOUNDARY)).flatMap((word) => citation_of(word) ?? []);
+}
+function is_cited(file, cited) {
+  return cited.some((path3) => file === path3 || file.endsWith(`${SEPARATOR2}${path3}`));
+}
+function files_read(reads) {
+  const paths = reads.flatMap(({ call }) => call.tool === READ_TOOL ? call.file_path ?? [] : []);
+  return [...new Set(paths)];
+}
+function tool_ms(entry) {
+  return Math.min(entry.call.duration_ms ?? 0, entry.active_ms);
+}
+function sum(values) {
+  return values.reduce((total4, value3) => total4 + value3, 0);
+}
+function breakdown(lane) {
+  const reads = lane_implement_stats.staged(lane.calls, lane.paused).filter((entry) => entry.stage === READ_STAGE);
+  const tool = sum(reads.map((entry) => tool_ms(entry)));
+  const files = files_read(reads);
+  const cited = cited_paths(lane.calls);
+  return {
+    tool_ms: tool,
+    thinking_ms: sum(reads.map((entry) => entry.active_ms)) - tool,
+    files: files.length,
+    cited: files.filter((file) => is_cited(file, cited)).length
+  };
+}
+function count_cell(values) {
+  return String(lane_stats.median(values) ?? lane_stats.MISSING);
+}
+function read_row(breakdowns) {
+  return [
+    READ_STAGE,
+    String(breakdowns.length),
+    lane_stage_stats.cell(lane_stats.median(breakdowns.map((lane) => lane.tool_ms))),
+    lane_stage_stats.cell(lane_stats.median(breakdowns.map((lane) => lane.thinking_ms))),
+    count_cell(breakdowns.map((lane) => lane.files)),
+    count_cell(breakdowns.map((lane) => lane.cited))
+  ];
+}
+function table10(calls, window, paused) {
+  const breakdowns = lane_implement_stats.implement_lanes(calls, window, paused).map((lane) => breakdown(lane));
+  return [
+    lane_stats.to_row(COLUMNS10),
+    lane_stats.to_row(COLUMNS10.map(() => "---")),
+    lane_stats.to_row(read_row(breakdowns))
+  ].join("\n");
+}
+var lane_implement_read = { table: table10 };
+
+// scripts/lane/lane-process-stats.ts
+var RSS_PEAK = "rss peak (GB)";
+var SAMPLES = "samples";
+var COLUMNS11 = [
+  "process",
+  "cpu mean (cores)",
+  "cpu peak (cores)",
+  RSS_PEAK,
+  "footprint peak (GB)",
+  SAMPLES
+];
+var RESIDENT_COLUMNS = ["resident apps", "rss median (GB)", RSS_PEAK, SAMPLES];
+var RESIDENT_LABEL = "summed";
+var PERCENT_PER_CORE = 100;
+var MB_PER_GB = 1024;
+var DECIMALS3 = 1;
+function is_load(entry) {
+  return entry.kind === "load";
+}
+function group(samples) {
+  const rows = /* @__PURE__ */ new Map();
+  const readings = samples.flatMap((sample) => sample.processes ?? []);
+  for (const reading of readings) {
+    const row = rows.get(reading.kind) ?? { kind: reading.kind, readings: [] };
+    row.readings.push(reading);
+    rows.set(reading.kind, row);
+  }
+  return [...rows.values()];
+}
+function cores(readings) {
+  return readings.map((reading) => reading.cpu_percent / PERCENT_PER_CORE);
+}
+function mean_cores(row) {
+  return lane_stats.mean(cores(row.readings)) ?? 0;
+}
+function cell(value3) {
+  return value3 === void 0 ? lane_stats.MISSING : value3.toFixed(DECIMALS3);
+}
+function peak_gb(sizes) {
+  const peak = lane_stats.peak(sizes);
+  return peak === void 0 ? void 0 : peak / MB_PER_GB;
+}
+function kind_cells(row) {
+  return [
+    row.kind,
+    cell(mean_cores(row)),
+    cell(lane_stats.peak(cores(row.readings))),
+    cell(peak_gb(row.readings.map((reading) => reading.rss_mb))),
+    cell(peak_gb(row.readings.flatMap((reading) => reading.footprint_mb ?? []))),
+    String(row.readings.length)
+  ];
+}
+function by_mean_cpu(left, right) {
+  return mean_cores(right) - mean_cores(left);
+}
+function to_table(columns, rows) {
+  return [
+    lane_stats.to_row(columns),
+    lane_stats.to_row(columns.map(() => "---")),
+    ...rows.map((row) => lane_stats.to_row(row))
+  ].join("\n");
+}
+function resident_tables(samples) {
+  const sizes = samples.flatMap((sample) => sample.resident_mb ?? []);
+  if (sizes.length === 0) return [];
+  const gigabytes = sizes.map((size) => size / MB_PER_GB);
+  const row = [RESIDENT_LABEL, cell(lane_stats.median(gigabytes)), cell(lane_stats.peak(gigabytes))];
+  return [to_table(RESIDENT_COLUMNS, [[...row, String(sizes.length)]])];
+}
+function table11(entries, window) {
+  const samples = lane_stats.in_window(entries, window).filter(is_load);
+  const rows = group(samples).toSorted(by_mean_cpu);
+  return [
+    to_table(
+      COLUMNS11,
+      rows.map((row) => kind_cells(row))
+    ),
+    ...resident_tables(samples)
+  ].join("\n\n");
+}
+var lane_process_stats = { table: table11 };
+
+// scripts/lane/lane-round-one-stats.ts
+var COLUMNS12 = ["round 1", "rounds", "share"];
+var VERDICTS = ["clean", "fixed", "blocking"];
+var { ROUND_ONE_REUSED: REUSED } = lane_ledger;
+var NO_SHARE = "-";
+var PERCENT = 100;
+function is_round_one(entry) {
+  return entry.kind === lane_ledger.KIND.ROUND_ONE;
+}
+function count_of(rounds, verdict) {
+  return rounds.filter((round) => round.verdict === verdict).length;
+}
+function share_of(count, ran) {
+  if (ran === 0) return NO_SHARE;
+  return `${String(Math.round(count * PERCENT / ran))}%`;
+}
+function table12(entries, window) {
+  const rounds = lane_stats.in_window(entries, window).filter(is_round_one);
+  const counts = VERDICTS.map((verdict) => count_of(rounds, verdict));
+  const ran = counts.reduce((sum2, count) => sum2 + count, 0);
+  const rows = VERDICTS.map((verdict, index) => {
+    const count = counts[index] ?? 0;
+    return lane_stats.to_row([verdict, String(count), share_of(count, ran)]);
+  });
+  return [
+    lane_stats.to_row(COLUMNS12),
+    lane_stats.to_row(COLUMNS12.map(() => "---")),
+    ...rows,
+    lane_stats.to_row([REUSED, String(count_of(rounds, REUSED)), NO_SHARE]),
+    lane_stats.to_row(["skipped", String(count_of(rounds, "skipped")), NO_SHARE])
+  ].join("\n");
+}
+var lane_round_one_stats = { table: table12 };
+
+// scripts/lane/lane-round-two-stats.ts
+var COLUMNS13 = ["round 2", "code", "decisions"];
+var KEY_SEPARATOR = " ";
+var NONE_ROW3 = ["none", "none", "0"];
+function is_round_two(entry) {
+  return entry.kind === lane_ledger.KIND.ROUND_TWO;
+}
+function counts_of(decisions) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const decision of decisions) {
+    const key = `${decision.verdict}${KEY_SEPARATOR}${decision.code}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function rows_of(counts) {
+  return [...counts].toSorted(([, left], [, right]) => right - left).map(([key, count]) => lane_stats.to_row([...key.split(KEY_SEPARATOR), String(count)]));
+}
+function table13(entries, window) {
+  const rows = rows_of(counts_of(lane_stats.in_window(entries, window).filter(is_round_two)));
+  return [
+    lane_stats.to_row(COLUMNS13),
+    lane_stats.to_row(COLUMNS13.map(() => "---")),
+    ...rows.length === 0 ? [lane_stats.to_row(NONE_ROW3)] : rows
+  ].join("\n");
+}
+var lane_round_two_stats = { table: table13 };
+
+// scripts/lane/lane-ship-lap-stats.ts
+var COLUMNS14 = ["ship step", "median (min)", "max (min)", "runs"];
+var STAGE_ORDER = lane_stage_stats.STAGES;
+function is_ship_lap(entry) {
+  return entry.kind === lane_ledger.KIND.SHIP_LAP && entry.reused_tree === void 0;
+}
+function groups_of(laps) {
+  const keys = [...new Map(laps.map((lap) => [`${lap.stage}
+${lap.step}`, lap])).values()];
+  return keys.map(({ stage, step }) => ({
+    stage,
+    step,
+    elapsed: laps.filter((lap) => lap.stage === stage && lap.step === step).map((lap) => lap.elapsed_ms)
+  }));
+}
+function stage_rank(stage) {
+  const index = STAGE_ORDER.indexOf(stage);
+  return index === -1 ? STAGE_ORDER.length : index;
+}
+function compare(left, right) {
+  const by_stage = stage_rank(left.stage) - stage_rank(right.stage);
+  if (by_stage !== 0) return by_stage;
+  return (lane_stats.median(right.elapsed) ?? 0) - (lane_stats.median(left.elapsed) ?? 0);
+}
+function row_of2(group2) {
+  return lane_stats.to_row([
+    `${group2.stage}: ${group2.step}`,
+    lane_stage_stats.cell(lane_stats.median(group2.elapsed)),
+    lane_stage_stats.cell(lane_stats.peak(group2.elapsed)),
+    String(group2.elapsed.length)
+  ]);
+}
+function table14(entries, window) {
+  const laps = lane_stats.in_window(entries, window).filter(is_ship_lap);
+  const rows = groups_of(laps).toSorted(compare).map((group2) => row_of2(group2));
+  return [...lane_check_stats.header(COLUMNS14), ...rows].join("\n");
+}
+var lane_ship_lap_stats = { table: table14 };
+
+// scripts/lane/lane-split-stats.ts
+var COLUMNS15 = ["reason", "noticed lanes", "split"];
+var REASONS = ["files", "hunks", "lines", "hub", "diff", "budget"];
+var ALL = "all";
+function reason_of2(entry) {
+  return entry.reason ?? "diff";
+}
+function row_of3(label, noticed, split) {
+  const split_count = [...noticed].filter((issue) => split.has(issue)).length;
+  return lane_stats.to_row([label, String(noticed.size), String(split_count)]);
+}
+function issues_of(notices, reason) {
+  return new Set(
+    notices.filter((entry) => reason === ALL || reason_of2(entry) === reason).map(({ issue }) => issue)
+  );
+}
+function table15(entries, window) {
+  const in_period = split_resolution.notices(lane_stats.in_window(entries, window));
+  const split = split_resolution.split_issues(entries);
+  const rows = [ALL, ...REASONS].map(
+    (reason) => row_of3(reason, issues_of(in_period, reason), split)
+  );
+  return [lane_stats.to_row(COLUMNS15), lane_stats.to_row(COLUMNS15.map(() => "---")), ...rows].join(
+    "\n"
+  );
+}
+var lane_split_stats = { table: table15 };
+
+// scripts/lane/lane-test-related-stats.ts
+var DECIMALS4 = 1;
+var RUNS_COLUMN = "runs";
+var SECONDS_COLUMN = "median (s)";
+var COLUMNS16 = [
+  "test:related scope",
+  RUNS_COLUMN,
+  "changed",
+  "synced",
+  "since map",
+  "readers",
+  "test files",
+  "select (s)",
+  SECONDS_COLUMN
+];
+var TRIGGER_COLUMNS = ["test:related whole-suite trigger", RUNS_COLUMN, SECONDS_COLUMN];
+function is_test_related(entry) {
+  return entry.kind === lane_ledger.KIND.TEST_RELATED;
+}
+function count_cell2(values) {
+  const median = lane_stats.median(values);
+  return median === void 0 ? lane_stage_stats.NOT_MEASURED : String(median);
+}
+function seconds_cell3(values) {
+  const median = lane_stats.median(values);
+  return median === void 0 ? lane_stage_stats.NOT_MEASURED : (median / MS_PER_SECOND).toFixed(DECIMALS4);
+}
+function median_of(runs, field) {
+  return count_cell2(runs.map((run2) => run2[field]));
+}
+function scope_row(scope, entries) {
+  const runs = entries.filter((entry) => entry.scope === scope);
+  const test_files = runs.map((run2) => run2.test_files).filter((files) => files !== void 0);
+  const selects = runs.map((run2) => run2.select_elapsed_ms).filter((ms) => ms !== void 0);
+  return lane_stats.to_row([
+    scope,
+    String(runs.length),
+    median_of(runs, "changed"),
+    median_of(runs, "synced"),
+    median_of(runs, "since_map"),
+    median_of(runs, "readers"),
+    count_cell2(test_files),
+    seconds_cell3(selects),
+    seconds_cell3(runs.map((run2) => run2.elapsed_ms))
+  ]);
+}
+function rows_under(columns, rows) {
+  return [lane_stats.to_row(columns), lane_stats.to_row(columns.map(() => "---")), ...rows].join(
+    "\n"
+  );
+}
+function runs_in(entries, window) {
+  return lane_stats.in_window(entries, window).filter(is_test_related);
+}
+function table16(entries, window) {
+  const runs = runs_in(entries, window);
+  const scopes = [...new Set(runs.map((run2) => run2.scope))];
+  return rows_under(
+    COLUMNS16,
+    scopes.map((scope) => scope_row(scope, runs))
+  );
+}
+function runs_sent_by(file, runs) {
+  return { file, runs: runs.filter((run2) => run2.trigger_files?.includes(file) === true) };
+}
+function trigger_row({ file, runs }) {
+  return lane_stats.to_row([
+    file,
+    String(runs.length),
+    seconds_cell3(runs.map((run2) => run2.elapsed_ms))
+  ]);
+}
+function trigger_table(entries, window) {
+  const runs = runs_in(entries, window);
+  const files = [...new Set(runs.flatMap((run2) => run2.trigger_files ?? []))];
+  const triggers = files.map((file) => runs_sent_by(file, runs)).toSorted((left, right) => right.runs.length - left.runs.length);
+  return rows_under(
+    TRIGGER_COLUMNS,
+    triggers.map((trigger) => trigger_row(trigger))
+  );
+}
+var lane_test_related_stats = { table: table16, trigger_table };
+
+// scripts/lane/lane-turn-stats.ts
+var BETWEEN = "between stages";
+var NO_TRANSCRIPT = "no transcript";
+var NO_VALUE = "-";
+var COLUMNS17 = [
+  "stage turns",
+  "calls per lane (median)",
+  "stops per lane (median)",
+  "lanes"
+];
+var ROWS = [...lane_stage_stats.STAGES, BETWEEN];
+function is_issue_stage(entry) {
+  return lane_stage_stats.is_stage(entry) && entry.issue !== void 0;
+}
+function is_lane_call(call) {
+  return call.issue !== void 0;
+}
+function stage_intervals(entries) {
+  return entries.filter((entry) => is_issue_stage(entry)).map((stage) => ({
+    issue: stage.issue,
+    stage: stage.stage,
+    from_ms: lane_stage_stats.started_ms(stage),
+    to_ms: Date.parse(stage.at)
+  }));
+}
+function intervals_of(entries) {
+  const implement = lane_stage_stats.implement_spans(entries).map(({ issue, from_ms, to_ms }) => ({
+    issue,
+    stage: lane_stage_stats.IMPLEMENT,
+    from_ms,
+    to_ms
+  }));
+  return [...implement, ...stage_intervals(entries)];
+}
+function span_ms(interval) {
+  return interval.to_ms - interval.from_ms;
+}
+function stage_of(at_ms, issue, intervals) {
+  const holding = intervals.filter(
+    (interval) => interval.issue === issue && at_ms >= interval.from_ms && at_ms <= interval.to_ms
+  );
+  return holding.toSorted((left, right) => span_ms(left) - span_ms(right))[0]?.stage ?? BETWEEN;
+}
+function issue_stages(calls, intervals) {
+  return calls.map((call) => ({ issue: lane_paused_spans.issue_of_lane(call.lane), at_ms: call.started_ms })).filter((call) => is_lane_call(call)).map(({ issue, at_ms }) => ({ issue, stage: stage_of(at_ms, issue, intervals) }));
+}
+function lane_stops(entries, issue) {
+  return entries.filter((entry) => entry.kind === lane_ledger.KIND.STOP).filter((stop) => stop.issue === issue).map(
+    (stop) => stop.reason === run_ship_stage.CONFLICT ? run_ship_stage.STAGE.SYNC : stop.reason
+  );
+}
+function lanes_of2(entries, calls) {
+  const stages = issue_stages(calls, intervals_of(entries));
+  const dispatches = entries.filter((entry) => lane_stage_stats.is_dispatch(entry));
+  const dispatched = new Set(dispatches.map(({ issue }) => issue));
+  const measured = [...dispatched].map((issue) => stages.filter((call) => call.issue === issue).map(({ stage }) => stage)).filter((lane) => lane.length > 0);
+  const stops = [...dispatched].map((issue) => lane_stops(entries, issue));
+  return { measured, stops, without: dispatched.size - measured.length };
+}
+function median_count(stage, lanes) {
+  const counts = lanes.map((lane) => lane.filter((name) => name === stage).length);
+  const median = lane_stats.median(counts);
+  return median === void 0 ? lane_stage_stats.NOT_MEASURED : String(median);
+}
+function stage_row(stage, lanes) {
+  return lane_stats.to_row([
+    stage,
+    median_count(stage, lanes.measured),
+    median_count(stage, lanes.stops),
+    String(lanes.measured.length)
+  ]);
+}
+function table17(entries, calls, window) {
+  const lanes = lanes_of2(
+    lane_stats.in_window(entries, window),
+    lane_transcript_stats.in_period(calls, window)
+  );
+  return [
+    lane_stats.to_row(COLUMNS17),
+    lane_stats.to_row(COLUMNS17.map(() => "---")),
+    ...ROWS.map((stage) => stage_row(stage, lanes)),
+    lane_stats.to_row([NO_TRANSCRIPT, NO_VALUE, NO_VALUE, String(lanes.without)])
+  ].join("\n");
+}
+var lane_turn_stats = { table: table17 };
+
+// scripts/lane/lane-stats-tables.ts
+function call_tables(entries, calls, window) {
+  const paused = lane_paused_spans.by_lane(entries);
+  return [
+    lane_implement_stats.table(calls, window, paused),
+    lane_implement_read.table(calls, window, paused),
+    lane_turn_stats.table(entries, calls, window)
+  ];
+}
+function stop_tables(entries, events, window) {
+  return [
+    lane_stop_stats.table(entries, window, events),
+    lane_chain_stop_stats.table(entries, window),
+    lane_gap_stats.table(entries, window, events),
+    lane_cut_stats.table(entries, window, events)
+  ];
+}
+function tables_of({ entries, events, calls }, window) {
+  return [
+    lane_stage_stats.table(entries, window),
+    lane_ship_lap_stats.table(entries, window),
+    lane_ci_path_stats.table(entries, window),
+    ...call_tables(entries, calls, window),
+    ...stop_tables(entries, events, window),
+    lane_round_one_stats.table(entries, window),
+    lane_round_two_stats.table(entries, window),
+    lane_early_push_stats.table(entries, window),
+    lane_split_stats.table(entries, window),
+    lane_size_stats.table(entries, window),
+    lane_implement_rate.table(entries, window),
+    lane_held_stats.table(entries, window),
+    lane_core_wait_stats.table(entries, window),
+    lane_process_stats.table(entries, window),
+    lane_check_stats.table(entries, window),
+    lane_claim_stats.table(entries, window),
+    lane_test_related_stats.table(entries, window),
+    lane_test_related_stats.trigger_table(entries, window),
+    lane_transcript_stats.table(calls, window),
+    lane_concurrency_stats.table(entries, calls, window)
+  ];
+}
+var lane_stats_tables = { tables_of };
+
+// scripts/lane/lane-value.ts
+var LINT_RELATED = "lint:related";
+var SHIP = "ship";
+var EDIT_TOOL = "Edit";
+var METRICS_STOPS = [
+  metrics_totals.METRICS_RERECORD_COMMAND,
+  metrics_totals.METRICS_TOTALS_COMMAND
+].map((list) => run_ship_pre_detach.failure_prefix(list));
+function seconds_of(ms) {
+  return ms === void 0 ? void 0 : ms / MS_PER_SECOND;
+}
+function per_lane(count, calls) {
+  const lanes = new Set(calls.map((call) => call.lane)).size;
+  return lanes === 0 ? void 0 : count / lanes;
+}
+function lint_unmoved({ calls }) {
+  const unmoved = lane_transcript_stats.solo_calls(calls, LINT_RELATED).filter((call) => call.output.includes(since_green.UNMOVED_REASON));
+  return seconds_of(lane_stats.median(lane_transcript_stats.durations(unmoved)));
+}
+function metrics_stops({ calls }) {
+  const stops = calls.filter(
+    (call) => lane_transcript_stats.verification_commands(call.command).includes(SHIP) && METRICS_STOPS.some((stop) => call.output.includes(stop))
+  );
+  return per_lane(stops.length, calls);
+}
+function is_lint_wait(entry) {
+  return entry.kind === lane_ledger.KIND.CORE_WAIT && entry.command === LINT_RELATED && entry.issue !== void 0;
+}
+function lint_core_wait({ entries, calls }) {
+  const waited = entries.filter((entry) => is_lint_wait(entry));
+  const total_ms2 = waited.reduce((sum2, wait) => sum2 + wait.waited_ms, 0);
+  return per_lane(total_ms2 / MS_PER_MINUTE, calls);
+}
+function edit({ calls }) {
+  const edits = calls.filter((call) => call.tool === EDIT_TOOL);
+  return seconds_of(lane_stats.median(lane_transcript_stats.durations(edits)));
+}
+var METRICS = {
+  "lint-unmoved": lint_unmoved,
+  "metrics-stops": metrics_stops,
+  "lint-core-wait": lint_core_wait,
+  edit
+};
+var NAMES = Object.keys(METRICS);
+function is_metric(name) {
+  return Object.hasOwn(METRICS, name);
+}
+function value(name, records, window) {
+  const metric = is_metric(name) ? METRICS[name] : void 0;
+  const period = {
+    entries: lane_stats.in_window(records.entries, window),
+    calls: lane_transcript_stats.in_period(records.calls, window)
+  };
+  return metric === void 0 ? void 0 : metric(period);
+}
+var lane_value = { NAMES, is_metric, value };
+
+// scripts/lane/lane-value-cell.ts
+var ROW_OPEN = "| ";
+var ROW_CLOSE = " |";
+var CELL_SEPARATOR = " | ";
+var BLOCK_SEPARATOR = /\n\s*\n/u;
+var NUMBER_PATTERN = /^-?\d+(?:\.\d+)?$/u;
+var HEADER_ROWS = 2;
+var LIST_SEPARATOR = ", ";
+var EMPTY_LIST = "-";
+var ITEM_PATTERN = /^(?<label>.+) (?<count>\d+)$/u;
+var ABSENT_COUNT = "0";
+function cells_of(line) {
+  const text = line.trim();
+  if (!text.startsWith(ROW_OPEN) || !text.endsWith(ROW_CLOSE)) return void 0;
+  return text.slice(ROW_OPEN.length, -ROW_CLOSE.length).split(CELL_SEPARATOR);
+}
+function rows_of2(block) {
+  return block.split("\n").map((line) => cells_of(line)).filter((row) => row !== void 0);
+}
+function blocks_of(tables) {
+  return tables.flatMap((table19) => table19.split(BLOCK_SEPARATOR)).map((block) => rows_of2(block)).filter((rows) => rows.length > 0);
+}
+function is_addressed(cells, header, address) {
+  const { row, where } = address;
+  if (row !== void 0 && cells[0] !== row) return false;
+  return where === void 0 || cells[header.indexOf(where.column)] === where.text;
+}
+function is_table(rows, address) {
+  const [header = []] = rows;
+  const columns = [address.column, address.where?.column ?? address.column];
+  return header[0] === address.table && columns.every((column) => header.includes(column));
+}
+function texts_in(rows, address) {
+  const [header = []] = rows;
+  const column = header.indexOf(address.column);
+  return rows.slice(HEADER_ROWS).filter((cells) => is_addressed(cells, header, address)).map((cells) => cells[column] ?? "");
+}
+function item_count(text, item) {
+  if (text === EMPTY_LIST) return ABSENT_COUNT;
+  const entries = text.split(LIST_SEPARATOR).map((entry) => ITEM_PATTERN.exec(entry)?.groups);
+  if (entries.includes(void 0)) return void 0;
+  return entries.find((groups) => groups?.["label"] === item)?.["count"] ?? ABSENT_COUNT;
+}
+function read_text(text, item) {
+  return item === void 0 ? text : item_count(text, item);
+}
+function numbers_in(texts, item) {
+  return texts.map((text) => read_text(text, item)).filter((text) => text !== void 0 && NUMBER_PATTERN.test(text));
+}
+function addressed(tables, address) {
+  const named = blocks_of(tables).filter((rows) => is_table(rows, address));
+  return { named, texts: named.flatMap((rows) => texts_in(rows, address)) };
+}
+function value2(tables, address) {
+  const { named, texts } = addressed(tables, address);
+  if (address.zero === true && named.length > 0 && texts.length === 0) return 0;
+  const numbers = numbers_in(texts, address.item);
+  return numbers.length === 1 ? Number(numbers[0]) : void 0;
+}
+function is_several(tables, address) {
+  return numbers_in(addressed(tables, address).texts, address.item).length > 1;
+}
+var lane_value_cell = { value: value2, is_several };
+
+// scripts/lane/lane-why-period.ts
+import path2 from "node:path";
+var CAUSE = {
+  IMPLEMENT: "implement (attribution unverified)",
+  IMPLEMENT_CLEAR: "implement (no signal over its bar)",
+  DRIVER: "driver followup over budget (outside lane net)",
+  PAUSE: "pause",
+  HUB: "hub over cap",
+  OTHER: "other"
+};
+var COLUMNS18 = ["cause", "lanes", "total net min", "open issues"];
+var KEY_SEPARATOR2 = ": ";
+var NO_KEYS = { ship: [] };
+function keyed_rows(budget, keys, fallback, name) {
+  if (keys.length === 0) return [[fallback, [name]]];
+  return keys.map((key) => [`${budget}${KEY_SEPARATOR2}${key}`, [key]]);
+}
+function rows_of3(budget, name, keys) {
+  if (budget === "followup") return [[CAUSE.DRIVER, [name]]];
+  if (budget === "ship") return keyed_rows(budget, keys.ship, budget, name);
+  if (budget !== "implement") return [[budget, [name]]];
+  if (keys.implement === void 0) return [[CAUSE.IMPLEMENT, [name]]];
+  return keyed_rows(budget, keys.implement, CAUSE.IMPLEMENT_CLEAR, name);
+}
+function add_names(groups, cause, names) {
+  groups.set(cause, [...groups.get(cause) ?? [], ...names]);
+}
+function add_signals(groups, breakdown2, hubs) {
+  const names = hubs.map((hub) => path2.basename(hub));
+  if ((breakdown2.pauses?.length ?? 0) > 0) add_names(groups, CAUSE.PAUSE, ["pause"]);
+  if (names.length > 0) groups.set(CAUSE.HUB, names);
+}
+function add_driver_keys(groups, keys) {
+  const names = groups.get(CAUSE.DRIVER);
+  if (names !== void 0) groups.set(CAUSE.DRIVER, [...names, ...keys]);
+}
+function causes_of3(breakdown2, hubs, keys = NO_KEYS) {
+  const groups = /* @__PURE__ */ new Map();
+  const rows = lane_why.over_stages(breakdown2).flatMap(({ stage, budget }) => rows_of3(budget, lane_sinks.base_name(stage.name), keys));
+  for (const [cause, names] of rows) add_names(groups, cause, names);
+  add_driver_keys(groups, keys.ship);
+  add_signals(groups, breakdown2, hubs);
+  if (groups.size === Number(groups.has(CAUSE.DRIVER))) groups.set(CAUSE.OTHER, []);
+  return groups;
+}
+function keys_of(records, issue) {
+  const signals = lane_implement_signals.signals_of(records.events, issue);
+  return {
+    ship: lane_why_causes.keys_of(records.entries, issue, void 0),
+    implement: signals === void 0 ? void 0 : lane_implement_signals.keys_of(signals)
+  };
+}
+function collect_lane(groups, records, issue) {
+  const breakdown2 = lane_breakdown.of(records.entries, records.events, issue);
+  if (breakdown2 === void 0) return;
+  const ms = breakdown2.stages.reduce((sum2, stage) => sum2 + stage.ms, 0);
+  const causes = causes_of3(
+    breakdown2,
+    lane_sinks.hubs_of(records.entries, [issue]),
+    keys_of(records, issue)
+  );
+  for (const [cause, names] of causes) {
+    groups.set(cause, [...groups.get(cause) ?? [], { ms, names }]);
+  }
+}
+function total_ms(lanes) {
+  return lanes.reduce((sum2, lane) => sum2 + lane.ms, 0);
+}
+function row_of4(cause, lanes, issues) {
+  return lane_stats.to_row([
+    cause,
+    String(lanes.length),
+    lane_stage_stats.cell(total_ms(lanes)),
+    lane_why_causes.open_cell(
+      lanes.flatMap((lane) => lane.names),
+      issues
+    )
+  ]);
+}
+function table18(records, window, minutes, issues) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const issue of lane_sinks.over_issues(records, window, minutes)) {
+    collect_lane(groups, records, issue);
+  }
+  const ranked2 = [...groups].toSorted((left, right) => total_ms(right[1]) - total_ms(left[1]));
+  return [
+    lane_stats.to_row(COLUMNS18),
+    lane_stats.to_row(COLUMNS18.map(() => "---")),
+    ...ranked2.map(([cause, lanes]) => row_of4(cause, lanes, issues))
+  ].join("\n");
+}
+var lane_why_period = { CAUSE, causes_of: causes_of3, table: table18 };
+
+// scripts/lane/lane-measure-cli.ts
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/lane/lane-measure-cli.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var ARGV_OFFSET = 2;
+var FAILURE_EXIT_CODE = 1;
+var SAMPLE_VERB = "sample";
+var STATS_VERB = "stats";
+var VALUE_VERB = "value";
+var NET_VERB = "net";
+var CELL_METRIC = "cell";
+var VALUE_DIGITS = 2;
+var USAGE = [
+  "Usage: josh lane:sample [--every <seconds>]",
+  "       josh lane:stats --period <days> [--limit <lane-limit>]",
+  "       josh lane:stats --period <days> --sinks [<minutes>]",
+  "       josh lane:stats --period <days> --over <minutes>",
+  "       josh lane:stats --period <days> --why <minutes>",
+  "       josh lane:stats --period <days> --pairs",
+  "       josh lane:stats --since <instant> \u2026 \u2014 any form above, the window opened at the instant",
+  `       josh lane:value <${lane_value.NAMES.join("|")}> --since <instant>`,
+  `       josh lane:value ${CELL_METRIC} --table <title> [--row <label>] [--where <header>=<text>] --column <header> [--item <label>] [--zero] --since <instant>`,
+  "       josh lane:net <issue>"
+].join("\n");
+var SAMPLE_OPTIONS = { every: { type: "string" } };
+var VALUE_OPTIONS = {
+  since: { type: "string" },
+  table: { type: "string" },
+  row: { type: "string" },
+  column: { type: "string" },
+  where: { type: "string" },
+  item: { type: "string" },
+  zero: { type: "boolean" }
+};
+var WHERE_SEPARATOR = "=";
+function refuse() {
+  console.error(USAGE);
+  return FAILURE_EXIT_CODE;
+}
+function sample_interval(rest) {
+  const values = cli_flags.values_of(rest, SAMPLE_OPTIONS);
+  if (values === void 0) return void 0;
+  if (values.every === void 0) return { seconds: void 0 };
+  const seconds2 = lane_stats_request.positive(values.every);
+  return seconds2 === void 0 ? void 0 : { seconds: seconds2 };
+}
+async function keep_sampling(context, seconds2) {
+  const ticks = every(seconds2 * MS_PER_SECOND, context);
+  for await (const tick_context of ticks) await lane_sampler.take(tick_context);
+}
+async function sample_command(rest, context) {
+  const interval = sample_interval(rest);
+  if (interval === void 0) return refuse();
+  await lane_sampler.take(context);
+  if (interval.seconds !== void 0) await keep_sampling(context, interval.seconds);
+  return 0;
+}
+function transcript_directories(context) {
+  if (context.transcript_directories !== void 0) return context.transcript_directories;
+  const main_cwd = cost_transcript.session_cwd(process.cwd());
+  return cost_transcript.lane_transcript_directories(main_cwd, cost_transcript.home_directory());
+}
+async function period_records(context, window) {
+  return {
+    entries: await lane_ledger_archive.read_history(context),
+    events: await lane_net_read.read_events(context),
+    calls: lane_transcript_stats.read_calls(transcript_directories(context), window)
+  };
+}
+function table_choice(request) {
+  if (request.why !== void 0) return { table: lane_why_period.table, minutes: request.why };
+  if (request.over !== void 0) return { table: lane_over_causes.view, minutes: request.over };
+  return request.sinks === void 0 ? void 0 : { table: lane_sinks.table, minutes: request.sinks };
+}
+async function threshold_text(choice, context, window) {
+  const sources = {
+    entries: await lane_ledger_archive.read_history(context),
+    events: await lane_net_read.read_events(context)
+  };
+  const issues = await lane_sinks_issues.read();
+  return session_cite.text(choice.table(sources, window, choice.minutes, issues));
+}
+async function stats_text(request, context, window) {
+  const choice = table_choice(request);
+  if (choice !== void 0) return await threshold_text(choice, context, window);
+  if (request.is_pairs) {
+    return lane_pairs.table(await lane_ledger_archive.read_history(context), window);
+  }
+  const records = await period_records(context, window);
+  const limit = await lane_limit_history.label(request.limit, records.entries, window);
+  const row = lane_stats.row(records.entries, window, { limit });
+  const tables = lane_stats_tables.tables_of(records, window);
+  return [`${lane_stats.header()}
+${row}`, ...tables].join("\n\n");
+}
+function window_of(start, now_ms) {
+  if ("since_ms" in start) return { since_ms: start.since_ms, until_ms: now_ms };
+  return lane_stats.window_of(start.period_days, now_ms);
+}
+async function stats_command(rest, context) {
+  const request = lane_stats_request.stats_request(rest);
+  if (request === void 0) return refuse();
+  const window = window_of(request.start, context.now_ms ?? Date.now());
+  console.info(await stats_text(request, context, window));
+  return 0;
+}
+function is_known(name) {
+  return name === CELL_METRIC || lane_value.is_metric(name);
+}
+function metric_of(positionals) {
+  const [name] = positionals;
+  return name !== void 0 && positionals.length === 1 && is_known(name) ? name : void 0;
+}
+function where_of(text) {
+  if (text === void 0) return { filter: void 0 };
+  const at = text.indexOf(WHERE_SEPARATOR);
+  if (at < 1) return void 0;
+  return { filter: { column: text.slice(0, at), text: text.slice(at + WHERE_SEPARATOR.length) } };
+}
+function address_of(flags) {
+  const { table: table19, column } = flags;
+  const where = where_of(flags.where);
+  if (table19 === void 0 || column === void 0 || where === void 0) return void 0;
+  return { table: table19, column, row: flags.row, where: where.filter, item: flags.item, zero: flags.zero };
+}
+function request_of(metric, since_ms) {
+  return metric === void 0 || since_ms === void 0 ? void 0 : { metric, since_ms };
+}
+function value_request(rest) {
+  const parsed = cli_flags.arguments_of(rest, VALUE_OPTIONS);
+  if (parsed === void 0) return void 0;
+  const request = request_of(
+    metric_of(parsed.positionals),
+    lane_stats_request.since_of(parsed.values.since)
+  );
+  if (request?.metric !== CELL_METRIC) return request;
+  const address = address_of(parsed.values);
+  return address === void 0 ? void 0 : { ...request, address };
+}
+function print_value(request, measured) {
+  const { value: value3, missing } = measured;
+  if (value3 === void 0) {
+    const since = new Date(request.since_ms).toISOString();
+    console.error(`josh lane:value ${request.metric}: ${missing} since ${since}`);
+    return FAILURE_EXIT_CODE;
+  }
+  console.info(value3.toFixed(VALUE_DIGITS));
+  return 0;
+}
+async function cell_value(address, window, context) {
+  const tables = lane_stats_tables.tables_of(await period_records(context, window), window);
+  const { MISSING } = lane_value_missing;
+  const is_several2 = lane_value_cell.is_several(tables, address);
+  return {
+    value: lane_value_cell.value(tables, address),
+    missing: is_several2 ? MISSING.SEVERAL : MISSING.CELL
+  };
+}
+async function value_command(rest, context) {
+  const request = value_request(rest);
+  if (request === void 0) return refuse();
+  const window = { since_ms: request.since_ms, until_ms: context.now_ms ?? Date.now() };
+  if (request.address !== void 0) {
+    return print_value(request, await cell_value(request.address, window, context));
+  }
+  const records = {
+    entries: await lane_ledger_archive.read_history(context),
+    calls: lane_transcript_stats.read_calls(transcript_directories(context), window)
+  };
+  const value3 = lane_value.value(request.metric, records, window);
+  return print_value(request, { value: value3, missing: lane_value_missing.MISSING.SAMPLE });
+}
+async function net_command(rest, context) {
+  const [issue = ""] = rest;
+  if (rest.length !== 1 || !issue_number_shape.is_issue_number(issue)) return refuse();
+  const net = await lane_net_read.net_minutes_of(Number(issue), context);
+  if (net === void 0) {
+    console.error(
+      `josh lane:net ${issue}: the ledger holds no dispatch and merge of ${session_cite.issue(issue)}`
+    );
+    return FAILURE_EXIT_CODE;
+  }
+  console.info(String(net));
+  return 0;
+}
+var VERBS = {
+  [SAMPLE_VERB]: sample_command,
+  [STATS_VERB]: stats_command,
+  [VALUE_VERB]: value_command,
+  [NET_VERB]: net_command
+};
+async function run(argv, context = {}) {
+  const [verb = "", ...rest] = argv;
+  const command = Object.hasOwn(VERBS, verb) ? VERBS[verb] : void 0;
+  return command === void 0 ? refuse() : await command(rest, context);
+}
+async function main(argv) {
+  process.exitCode = await run(argv);
+}
+var lane_measure_cli = {
+  USAGE,
+  run
+};
+if (process.argv[1] === fileURLToPath(__josh_source_url)) await main(process.argv.slice(ARGV_OFFSET));
+export {
+  lane_measure_cli
+};