@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-TFLHYC2F.js

@@ -1,141 +0,0 @@
-import {
-  lane_yield
-} from "./chunk-EGIHAEMT.js";
-import {
-  run_event_scope
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-
-// scripts/run/event/run-event-retry.ts
-var RETRY_PREFIX = "retry #";
-function text_of(issue) {
-  return `${RETRY_PREFIX}${String(issue)}`;
-}
-function is_retry(event) {
-  return event.kind === run_event_stream.EVENT_KIND.ADD && event.text.startsWith(RETRY_PREFIX);
-}
-function current_attempts(events) {
-  const boundaries = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    if (is_retry(event)) boundaries.set(run_event_scope.issue_named(event), event.pos);
-  }
-  return events.filter(
-    (event) => event.pos >= (boundaries.get(run_event_scope.issue_named(event)) ?? 0)
-  );
-}
-function count_of(events, issue) {
-  return events.filter(
-    (event) => is_retry(event) && run_event_scope.issue_named(event) === String(issue)
-  ).length;
-}
-var run_event_retry = { count_of, current_attempts, is_retry, text_of };
-
-// scripts/backlog/backlog-offer-exclude.ts
-var LIST_SEPARATOR = ",";
-function exclude_of(settled, in_flight) {
-  return [.../* @__PURE__ */ new Set([...settled, ...in_flight])];
-}
-function exclude_argv(exclude) {
-  return exclude.length === 0 ? [] : ["--exclude", exclude.join(LIST_SEPARATOR)];
-}
-var backlog_offer_exclude = { exclude_argv, exclude_of };
-
-// scripts/backlog/backlog-drive-restore.ts
-var ISSUE_IN_EVENT = /#([1-9]\d*)\b/u;
-var SETTLED_KINDS = /* @__PURE__ */ new Set([
-  run_event_stream.EVENT_KIND.MERGE,
-  run_event_stream.EVENT_KIND.PARK,
-  run_event_stream.EVENT_KIND.HUMAN_REVIEW,
-  run_event_stream.EVENT_KIND.SPLIT,
-  run_event_stream.EVENT_KIND.WITHDRAW,
-  run_event_stream.EVENT_KIND.OUTAGE,
-  run_event_stream.EVENT_KIND.USAGE_LIMIT
-]);
-var DONE_KINDS = /* @__PURE__ */ new Set([
-  run_event_stream.EVENT_KIND.MERGE,
-  run_event_stream.EVENT_KIND.PARK,
-  run_event_stream.EVENT_KIND.HUMAN_REVIEW,
-  run_event_stream.EVENT_KIND.SPLIT,
-  run_event_stream.EVENT_KIND.WITHDRAW
-]);
-function issue_of(event) {
-  return ISSUE_IN_EVENT.exec(event.text)?.[1];
-}
-function update_active(active, event) {
-  const issue = issue_of(event);
-  if (issue === void 0) return;
-  if (event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH) active.add(issue);
-  if (SETTLED_KINDS.has(event.kind)) active.delete(issue);
-}
-function active_issues(events) {
-  const active = /* @__PURE__ */ new Set();
-  for (const event of events) update_active(active, event);
-  return active;
-}
-function settled_issues(events) {
-  const settled = run_event_retry.current_attempts(events).filter((event) => DONE_KINDS.has(event.kind) && !lane_yield.is_yield(event));
-  return new Set(
-    settled.map((event) => issue_of(event)).filter((issue) => issue !== void 0).map(Number)
-  );
-}
-function issues_of_kind(events, kind) {
-  return events.filter((event) => event.kind === kind).map((event) => issue_of(event)).filter((issue) => issue !== void 0);
-}
-function withdrawn_issues(events) {
-  const named = issues_of_kind(events, run_event_stream.EVENT_KIND.WITHDRAW);
-  return named.filter(
-    (issue) => run_event_scope.is_withdrawn(events, issue) && !lane_yield.is_yielded(events, issue)
-  );
-}
-function waiting_issues(events) {
-  return [...new Set(issues_of_kind(events, run_event_stream.EVENT_KIND.SAMPLE_WAIT))];
-}
-function left_out(events, carried) {
-  const exclude = [.../* @__PURE__ */ new Set([...carried, ...withdrawn_issues(events)])];
-  return { exclude, waiting: [...waiting_issues(events)] };
-}
-function offer_exclude(events) {
-  const merged = issues_of_kind(events, run_event_stream.EVENT_KIND.MERGE);
-  const settled = [...merged, ...waiting_issues(events), ...withdrawn_issues(events)];
-  return backlog_offer_exclude.exclude_of(settled, active_issues(events));
-}
-function parked_issues(events) {
-  return new Set(
-    issues_of_kind(run_event_retry.current_attempts(events), run_event_stream.EVENT_KIND.PARK).map(
-      Number
-    )
-  );
-}
-function mentioned_issues(events) {
-  const tracked = events.filter(
-    (event) => event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH || SETTLED_KINDS.has(event.kind)
-  );
-  return new Set(tracked.map((event) => issue_of(event)).filter((issue) => issue !== void 0));
-}
-function restore(lanes, events, merged_issues, dispatched = []) {
-  const active = active_issues(events);
-  const mentioned = mentioned_issues(events);
-  const carried = new Set(dispatched.filter((issue) => !mentioned.has(issue)));
-  return lanes.filter(
-    (issue) => (active.has(issue) || carried.has(issue)) && !merged_issues.includes(Number(issue))
-  );
-}
-var backlog_drive_restore = {
-  DONE_KINDS,
-  active_issues,
-  left_out,
-  mentioned_issues,
-  offer_exclude,
-  restore,
-  withdrawn_issues,
-  settled_issues,
-  parked_issues
-};
-
-export {
-  run_event_retry,
-  backlog_offer_exclude,
-  backlog_drive_restore
-};

package/dist/commands/chunk-TJKM56WJ.js

@@ -1,109 +0,0 @@
-import {
-  review_round2
-} from "./chunk-RVUJ6F5L.js";
-import {
-  review_finding_ledger
-} from "./chunk-KVURNO74.js";
-import {
-  review_code_tree
-} from "./chunk-KK2SL42W.js";
-import {
-  review_attest
-} from "./chunk-KIILCKQR.js";
-import {
-  observation_ledger_home
-} from "./chunk-WWVYEHQT.js";
-import {
-  project_checks
-} from "./chunk-JM6EVOFN.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  changed_paths
-} from "./chunk-V5FD7DVV.js";
-import {
-  change_base
-} from "./chunk-36LOGVJ7.js";
-
-// scripts/review/review-interaction.ts
-var TARGET_DIRECTORIES = ["scripts/run/", "scripts/lane/", "scripts/backlog/", "scripts/hooks/"];
-var NOT_DUE_LINE = "Interaction review not due: this is not the kit repository, or the change touches none of scripts/run/, scripts/lane/, scripts/backlog/ or scripts/hooks/.";
-var QUESTIONS = [
-  "1. Every state, command, label, file or process this change adds or gives a new meaning to \u2014 who else reads or writes it? Search the repository outside the diff for each. Where the plan has a `### \u5F71\u97FF\u3092\u53D7\u3051\u308B\u65E2\u5B58\u306E\u5229\u7528\u8005` section, check it names them all.",
-  "2. Does each of those readers and writers still behave correctly when the new state or value reaches it (for example, a paused lane counted as running)?",
-  "3. Does the change add heavy or synchronous work to a path called repeatedly \u2014 every second, every Bash call, every edit?"
-];
-var ROLE_LINES = [
-  "## Interaction review",
-  "This pass is not a second `/code-review`: do not hunt for bugs inside the diff \u2014 the round before it did. Your role is to find three existing features this change breaks. Check only these three:",
-  ...QUESTIONS,
-  "Report each break with the reader's `file:line` and the change's, rated by the rubric's severities; it is disposed of by `prompts/review.md` \u2192 \"Interaction review\"."
-];
-var INERT_LINE_PREFIX = "Interaction review not due: every run-tooling path this change touches leaves what executes unchanged (round 2\u2019s inert reading \u2014 in these directories, an edit to comments or import specifiers only)";
-var NOT_REQUIRED = "not-required";
-function due_paths(paths, checkout = process.cwd()) {
-  if (!project_checks.is_kit_repository(checkout)) return [];
-  return paths.filter((file) => TARGET_DIRECTORIES.some((directory) => file.startsWith(directory)));
-}
-function brief_block(targets) {
-  const listed = targets.map((file) => `- ${file}`);
-  return [...ROLE_LINES, "Changed in the run tooling:", ...listed].join("\n");
-}
-async function inert_line(due) {
-  const base = await change_base.resolved_through_merge();
-  if (base === void 0) return void 0;
-  const inert = await review_code_tree.inert_since(base, due);
-  const is_inert = due.every((relative) => review_round2.is_unexecuted(relative, inert));
-  return is_inert ? `${INERT_LINE_PREFIX}: ${due.join(", ")}` : void 0;
-}
-async function unrecorded_reading(due) {
-  const line = await inert_line(due);
-  return line === void 0 ? { status: "missing" } : { status: NOT_REQUIRED, inert_line: line };
-}
-async function reading_of(issue, paths, root = observation_ledger_home.ledger_root()) {
-  const due = due_paths(paths);
-  const content = due.length > 0 ? await observation_ledger_home.read(root) : void 0;
-  if (content === void 0) return { status: NOT_REQUIRED };
-  if (review_finding_ledger.has_issue_record(content, issue, "interaction")) return { status: "ok" };
-  return await unrecorded_reading(due);
-}
-async function status_of(issue, paths, root) {
-  const answer = await reading_of(issue, paths, root);
-  return answer.status;
-}
-async function reading(issue, root) {
-  return await reading_of(issue, await changed_paths.read_changed_paths(false), root);
-}
-async function status(issue, root) {
-  const answer = await reading(issue, root);
-  return answer.status;
-}
-function round_one_slots(answer) {
-  const { CODE, INTERACTION } = review_attest.REVIEW_SLOT;
-  return answer === "missing" ? [CODE, INTERACTION] : [CODE];
-}
-var MISSING_REASON = "This change touches the run tooling, and no interaction review is recorded for its issue \u2014 the pass that looks for the existing features a change breaks, which `/code-review` does not (joshuafolkken/kit#4276).";
-var REMEDY = "Run it from `pnpm josh review:brief --interaction`, whose reviewer writes its findings with `pnpm josh review:submit --interaction`; record them with `pnpm josh review:record --from-slot --interaction --issue <N> [<n>=<disposition> ...]` and reissue the merge.";
-function refusal_message(issue) {
-  return [MISSING_REASON, `Issue: ${session_cite.issue(issue)}`, REMEDY].join("\n");
-}
-async function refusal(issue, root) {
-  return await status(issue, root) === "missing" ? refusal_message(issue) : void 0;
-}
-var review_interaction = {
-  brief_block,
-  due_paths,
-  NOT_DUE_LINE,
-  QUESTIONS,
-  reading,
-  refusal,
-  refusal_message,
-  round_one_slots,
-  status,
-  status_of
-};
-
-export {
-  review_interaction
-};

package/dist/commands/chunk-TLAB552K.js

@@ -1,445 +0,0 @@
-import {
-  lane_stage_budget
-} from "./chunk-AXXEMVRJ.js";
-import {
-  lane_breakdown_laps
-} from "./chunk-QMDKDQKW.js";
-import {
-  lane_breakdown_calls,
-  lane_breakdown_implement
-} from "./chunk-BYGJ3BCJ.js";
-import {
-  lane_breakdown
-} from "./chunk-MLW4S35K.js";
-import {
-  lane_net_time
-} from "./chunk-MWO6FOSZ.js";
-import {
-  lane_stage_stats
-} from "./chunk-IBAYXCMU.js";
-import {
-  lane_stats
-} from "./chunk-XXC32PVL.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-import {
-  MS_PER_MINUTE,
-  MS_PER_SECOND
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lane/lane-breakdown-pinned.ts
-var MAX_SHOWN = 5;
-var DISCARDED_LABEL = "background test:pinned probes discarded";
-var TYPE_CHECK_LABEL = "type check";
-function is_lane_row(entry, issue) {
-  return entry.kind === lane_ledger.KIND.TEST_PINNED && entry.issue === issue;
-}
-function is_discarded(entry) {
-  return entry.discarded === true;
-}
-function is_in_pre_detach(entry, breakdown) {
-  const at_ms = Date.parse(entry.at);
-  return breakdown.pre_detach.some((span) => at_ms >= span.from_ms && at_ms <= span.to_ms);
-}
-function rows_of(entries, issue, breakdown) {
-  return entries.filter((entry) => is_lane_row(entry, issue)).filter((entry) => !is_discarded(entry) && is_in_pre_detach(entry, breakdown));
-}
-function discarded_text(entries, issue) {
-  const rows = entries.filter((entry) => is_lane_row(entry, issue)).filter((entry) => is_discarded(entry));
-  if (rows.length === 0) return "";
-  const elapsed_ms = rows.reduce((sum, row) => sum + row.elapsed_ms, 0);
-  return `${DISCARDED_LABEL} ${String(rows.length)}, ${lane_breakdown.minutes_text(elapsed_ms)}`;
-}
-function probe_text(probe) {
-  const tests = probe.tests === void 0 ? "" : ` ${String(probe.tests)} test files`;
-  const pinned_by = probe.pinned_by === void 0 ? "" : ` (${TYPE_CHECK_LABEL})`;
-  return `${probe.file}${tests} ${lane_breakdown.minutes_text(probe.elapsed_ms)}${pinned_by}`;
-}
-function skipped_counts(rewired, over_cap) {
-  const named = [
-    [rewired, "rewired"],
-    [over_cap, "over cap"]
-  ];
-  return named.filter(([count2]) => count2 > 0).map(([count2, label]) => `${String(count2)} ${label}`);
-}
-function detail_text(rows) {
-  if (rows.length === 0) return "";
-  const probes = rows.flatMap((row) => row.probes).toSorted((left, right) => right.elapsed_ms - left.elapsed_ms);
-  const held = rows.reduce((sum, row) => sum + row.held, 0);
-  const rewired = rows.reduce((sum, row) => sum + (row.rewired ?? 0), 0);
-  const over_cap = rows.reduce((sum, row) => sum + (row.over_cap ?? 0), 0);
-  const total = held + rewired + over_cap + probes.length;
-  const head = `test:pinned ${String(total)} hunks, ${String(held)} cached, ${String(probes.length)} probed`;
-  const counts = [head, ...skipped_counts(rewired, over_cap)];
-  return ` (${[...counts, ...probes.slice(0, MAX_SHOWN).map((probe) => probe_text(probe))].join(", ")})`;
-}
-var lane_breakdown_pinned = { detail_text, discarded_text, rows_of };
-
-// scripts/lane/lane-breakdown-related.ts
-var LABEL = "test:related";
-function is_lane_row2(entry, issue) {
-  return entry.kind === lane_ledger.KIND.TEST_RELATED && entry.issue === issue;
-}
-function top_hub(rows) {
-  const tally = /* @__PURE__ */ new Map();
-  for (const { over_cap_hub } of rows) {
-    if (over_cap_hub !== void 0) tally.set(over_cap_hub, (tally.get(over_cap_hub) ?? 0) + 1);
-  }
-  return [...tally].toSorted((first, second) => second[1] - first[1])[0]?.[0];
-}
-function over_cap_text(entries, issue) {
-  const rows = entries.filter((entry) => is_lane_row2(entry, issue));
-  const over_cap = Math.max(0, ...rows.map((row) => row.over_cap ?? 0));
-  if (over_cap === 0) return "";
-  const capped = rows.filter((row) => (row.over_cap ?? 0) > 0).length;
-  const hub = top_hub(rows);
-  const text2 = `${LABEL} ${String(over_cap)} over cap, in ${String(capped)} of ${String(rows.length)} runs`;
-  return hub === void 0 ? text2 : `${text2}, hub ${hub}`;
-}
-var lane_breakdown_related = { over_cap_text };
-
-// scripts/lane/lane-check-stats.ts
-var DECIMALS = 1;
-var WHOLE_GATE_LABEL = "gate (whole)";
-var COLUMNS = ["check", "median (s)", "max (s)", "runs", "reused", "no-op", "fallback"];
-var FALLBACK_COLUMNS = ["fallback reason", "runs"];
-var RELATED_LABEL = "test:related";
-function is_gate(entry) {
-  return entry.kind === lane_ledger.KIND.GATE;
-}
-function cell(milliseconds) {
-  return milliseconds === void 0 ? lane_stage_stats.NOT_MEASURED : (milliseconds / MS_PER_SECOND).toFixed(DECIMALS);
-}
-function header(columns) {
-  return [lane_stats.to_row(columns), lane_stats.to_row(columns.map(() => "---"))];
-}
-function count(runs, is_counted) {
-  return String(runs.filter((check) => is_counted(check)).length);
-}
-function check_row(label, checks) {
-  const runs = checks.filter((check) => check.label === label);
-  const timed = runs.filter((check) => check.is_reused !== true && check.is_unmoved !== true);
-  const elapsed = timed.map((check) => check.elapsed_ms);
-  return lane_stats.to_row([
-    label,
-    cell(lane_stats.median(elapsed)),
-    cell(lane_stats.peak(elapsed)),
-    String(runs.length),
-    count(runs, (check) => check.is_reused === true),
-    count(runs, (check) => check.is_unmoved === true),
-    count(runs, (check) => check.fallback !== void 0)
-  ]);
-}
-function whole_gate(gate) {
-  return {
-    label: WHOLE_GATE_LABEL,
-    elapsed_ms: gate.elapsed_ms,
-    is_passed: gate.is_passed,
-    is_reused: gate.is_reused
-  };
-}
-function is_push_miss(entry) {
-  return entry.kind === lane_ledger.KIND.PUSH_MISS;
-}
-function is_related_lap(entry) {
-  return entry.kind === lane_ledger.KIND.SHIP_LAP && entry.step.split(" \u203A ").at(-1) === RELATED_LABEL;
-}
-function related_checks(entries) {
-  return entries.filter(is_related_lap).map((entry) => ({
-    label: RELATED_LABEL,
-    elapsed_ms: entry.elapsed_ms,
-    is_reused: entry.is_reused
-  }));
-}
-function push_reason(miss) {
-  return `pre-push ${miss.scope}: ${miss.reason}`;
-}
-function fallback_table(checks, misses) {
-  const fallbacks = checks.map((check) => check.fallback).filter((reason) => reason !== void 0);
-  const reasons = [...fallbacks, ...misses.map((miss) => push_reason(miss))];
-  const kinds = [...new Set(reasons)];
-  const rows = kinds.map(
-    (kind) => lane_stats.to_row([kind, String(reasons.filter((reason) => reason === kind).length)])
-  );
-  return [...header(FALLBACK_COLUMNS), ...rows].join("\n");
-}
-function table(entries, window) {
-  const windowed = lane_stats.in_window(entries, window);
-  const gates = windowed.filter(is_gate);
-  const checks = [...gates.flatMap((gate) => gate.checks ?? []), ...related_checks(windowed)];
-  const rows = [...gates.map((gate) => whole_gate(gate)), ...checks];
-  const labels = [...new Set(rows.map((row) => row.label))];
-  return [
-    [...header(COLUMNS), ...labels.map((label) => check_row(label, rows))].join("\n"),
-    fallback_table(checks, windowed.filter(is_push_miss))
-  ].join("\n\n");
-}
-var lane_check_stats = { WHOLE_GATE_LABEL, cell, header, table };
-
-// scripts/lane/lane-ci-path-stats.ts
-var COLUMNS2 = ["followup critical path", "runs", "median (s)", "max (s)"];
-function settled({ last_check, check_ms }) {
-  if (last_check === void 0) return void 0;
-  const elapsed_ms = check_ms?.[last_check];
-  return elapsed_ms === void 0 ? void 0 : { name: last_check, elapsed_ms };
-}
-function last_check_of(entry) {
-  if (entry.kind !== lane_ledger.KIND.STAGE || entry.stage !== lane_ledger_write.CI_WAIT_STAGE) {
-    return void 0;
-  }
-  return settled(entry);
-}
-function name_row(name, lasts) {
-  const elapsed = lasts.filter((last) => last.name === name).map((last) => last.elapsed_ms);
-  return lane_stats.to_row([
-    name,
-    String(elapsed.length),
-    lane_check_stats.cell(lane_stats.median(elapsed)),
-    lane_check_stats.cell(lane_stats.peak(elapsed))
-  ]);
-}
-function table2(entries, window) {
-  const lasts = lane_stats.in_window(entries, window).filter((entry) => entry.kind !== lane_ledger.KIND.STAGE || entry.has_rerun !== true).map((entry) => last_check_of(entry)).filter((last) => last !== void 0);
-  const names = [...new Set(lasts.map((last) => last.name))];
-  return [...lane_check_stats.header(COLUMNS2), ...names.map((name) => name_row(name, lasts))].join(
-    "\n"
-  );
-}
-function latest_check(entries, issue) {
-  return entries.filter((entry) => entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue).map((entry) => last_check_of(entry)).findLast((found) => found !== void 0);
-}
-function last_check_name(entries, issue) {
-  return latest_check(entries, issue)?.name;
-}
-function last_check_text(entries, issue) {
-  const last = latest_check(entries, issue);
-  return last === void 0 ? "" : ` (last check: ${last.name} ${lane_check_stats.cell(last.elapsed_ms)}s)`;
-}
-var lane_ci_path_stats = { last_check_name, last_check_text, table: table2 };
-
-// scripts/lane/lane-elapsed-time.ts
-var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write"]);
-var AUTOMATIC_STAGES = /* @__PURE__ */ new Set([
-  "gate",
-  "pre-detach",
-  "followup",
-  lane_ledger.CI_WAIT_STAGE
-]);
-function tool_spans(calls) {
-  return calls.flatMap(
-    (call) => call.duration_ms === void 0 || EDIT_TOOLS.has(call.tool ?? "") ? [] : { from_ms: call.started_ms, to_ms: call.started_ms + call.duration_ms }
-  );
-}
-function stage_spans(entries, issue) {
-  return entries.flatMap(
-    (entry) => entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue && AUTOMATIC_STAGES.has(entry.stage) ? { from_ms: Date.parse(entry.at) - entry.elapsed_ms, to_ms: Date.parse(entry.at) } : []
-  );
-}
-function human_spans(entries, events, issue, span) {
-  return lane_net_time.hold_waits(
-    entries,
-    events.filter((event) => event.kind === "park"),
-    issue,
-    span
-  );
-}
-function tool_ms(span, calls) {
-  return tool_spans(calls).reduce((sum, call) => sum + lane_breakdown.covered_ms(span, [call]), 0);
-}
-function partition(span, human, automatic, calls) {
-  const total_ms = span.to_ms - span.from_ms;
-  const human_ms = lane_breakdown.covered_ms(span, human);
-  const occupied_ms = lane_breakdown.covered_ms(span, [...human, ...automatic]);
-  const remainder_ms = total_ms - occupied_ms;
-  return {
-    total_ms,
-    human_ms,
-    automatic_ms: occupied_ms - human_ms,
-    work_ms: calls.length > 0 ? remainder_ms : 0,
-    unclassified_ms: calls.length > 0 ? 0 : remainder_ms,
-    tool_ms: tool_ms(span, calls),
-    within_target: total_ms <= lane_stage_budget.TARGET_MINUTES * MS_PER_MINUTE
-  };
-}
-function of(entries, events, issue, calls) {
-  const span = lane_net_time.span_of(entries, issue);
-  if (span === void 0) return void 0;
-  const human = human_spans(entries, events, issue, span);
-  const automatic = [
-    ...lane_net_time.automatic_waits(entries, events, issue, span),
-    ...stage_spans(entries, issue),
-    ...tool_spans(calls)
-  ];
-  return partition(span, human, automatic, calls);
-}
-function text(timing) {
-  const minutes = lane_breakdown.minutes_text;
-  const status = timing.within_target ? "within target" : "over target";
-  return [
-    `End-to-end ${minutes(timing.total_ms)} (${status}); ${lane_stage_budget.DESCRIPTION}`,
-    `Exclusive wall clock: off-tool work ${minutes(timing.work_ms)}; automatic wait ${minutes(timing.automatic_ms)}; human wait ${minutes(timing.human_ms)}; unclassified (missing transcripts) ${minutes(timing.unclassified_ms)}`,
-    `Tool cumulative ${minutes(timing.tool_ms)} (parallel calls overlap; not additive to wall clock). Off-tool work includes unrecorded activity; automatic wait includes tool responses, gate, CI, yield, outage and sleep. Legacy net excludes more than human wait.`
-  ].join("\n");
-}
-var lane_elapsed_time = { of, text };
-
-// scripts/lane/lane-breakdown-text.ts
-var HEADING = "Net time by stage, longest first";
-var EXCLUDED = "waits taken out (park, outage, usage limit, yield, split run, host sleep)";
-var SLEPT = "of which host sleep";
-var YIELDED = "of which yield wait";
-var HOLDER = "yield wait: holder remaining";
-var GAP = "yield wait: redispatch gap (offer + launch)";
-var UNSPLIT = "yield wait: no holder named, unsplit";
-var OUTSIDE = "outside calls";
-var DRIVER = "(outside lane net)";
-function part_text(part) {
-  return `${part.name} ${lane_breakdown.minutes_text(part.ms)}`;
-}
-function budget_of(name) {
-  const stages = {
-    [lane_breakdown.PLAN_STAGE]: "plan",
-    [lane_breakdown.IMPLEMENT_STAGE]: "implement",
-    [lane_breakdown.DRIVER_FOLLOWUP_STAGE]: "followup"
-  };
-  const ship = lane_breakdown.is_ship_stage(name) ? "ship" : void 0;
-  return stages[name] ?? ship;
-}
-function over_text(stage) {
-  const budget = budget_of(stage.name);
-  const over = budget === void 0 ? void 0 : lane_stage_budget.over_minutes(budget, stage.ms);
-  return over === void 0 ? "" : `, over budget +${String(over)} min`;
-}
-function kind_text(kind, untimed) {
-  const count2 = untimed.get(kind.name) ?? 0;
-  return count2 > 0 ? `${part_text(kind)} + ${String(count2)} backgrounded, untimed` : part_text(kind);
-}
-function detail_text2(detail) {
-  const kinds = detail.kinds.map((kind) => kind_text(kind, detail.untimed));
-  const count2 = String(detail.background);
-  const background = detail.background > 0 ? [`${count2} backgrounded calls, their waits in editing & thinking`] : [];
-  return ` (${[...kinds, ...background].join(", ")})`;
-}
-function reason_text(reason) {
-  return reason === void 0 ? "" : ` (${reason})`;
-}
-function outside_text(outside) {
-  if (outside === void 0) return void 0;
-  const minutes = `${OUTSIDE} ${lane_breakdown.minutes_text(outside.ms)}`;
-  const count2 = String(outside.background);
-  const background = outside.background > 0 ? [`${count2} backgrounded calls, their waits in it`] : [];
-  return ` (${[minutes, ...background].join(", ")})`;
-}
-function suffix_of(name, report) {
-  const suffixes = {
-    [lane_breakdown.PLAN_STAGE]: outside_text(report.plan_outside),
-    [lane_breakdown.IMPLEMENT_STAGE]: detail_text2(report.detail),
-    [lane_breakdown.PRE_DETACH_STAGE]: report.pinned
-  };
-  return suffixes[name] ?? reason_text(report.breakdown.reasons?.get(name));
-}
-function implement_calls(detail) {
-  return detail.kinds.flatMap(
-    (kind) => (detail.calls?.get(kind.name) ?? []).map(
-      (group) => `${kind.name} \u203A ${lane_breakdown_calls.group_text(group)}`
-    )
-  );
-}
-function calls_of(name, report) {
-  if (name === lane_breakdown.IMPLEMENT_STAGE) return implement_calls(report.detail);
-  if (name !== lane_breakdown.PLAN_STAGE) return [];
-  return (report.plan_calls ?? []).map((group) => lane_breakdown_calls.group_text(group));
-}
-function stage_entry(stage, report) {
-  const laps = report.laps?.get(stage.name) ?? [];
-  return {
-    text: `${part_text(stage)}${over_text(stage)}${suffix_of(stage.name, report)}`,
-    laps: laps.map((lap) => part_text(lap)),
-    calls: calls_of(stage.name, report)
-  };
-}
-function yield_lines(breakdown) {
-  const split = breakdown.yield_split;
-  if (split === void 0 || breakdown.yield_ms === 0) return [];
-  const named = [
-    { name: HOLDER, ms: split.holder_ms },
-    { name: GAP, ms: split.gap_ms }
-  ];
-  const unsplit = [{ name: UNSPLIT, ms: split.unsplit_ms }];
-  return [
-    ...split.holder_ms + split.gap_ms > 0 ? named : [],
-    ...split.unsplit_ms > 0 ? unsplit : []
-  ].map((part) => part_text(part));
-}
-function excluded_entry(breakdown) {
-  const yielded = `${YIELDED} ${lane_breakdown.minutes_text(breakdown.yield_ms)}`;
-  const slept = `${SLEPT} ${lane_breakdown.minutes_text(breakdown.slept_ms)}`;
-  const excluded = `${EXCLUDED} ${lane_breakdown.minutes_text(breakdown.excluded_ms)}, ${yielded}, ${slept}`;
-  return { text: excluded, laps: yield_lines(breakdown), calls: [] };
-}
-function driver_entry(stage, report) {
-  const laps = report.laps?.get(lane_breakdown.FOLLOWUP_STAGE) ?? [];
-  return {
-    text: `${part_text(stage)} ${DRIVER}${over_text(stage)}${report.critical ?? ""}`,
-    laps: laps.map((lap) => part_text(lap)),
-    calls: []
-  };
-}
-function entries_of(report) {
-  const { breakdown } = report;
-  const notes = [report.discarded, report.related].filter((text2) => text2 !== void 0 && text2 !== "").map((text2) => ({ text: text2, laps: [], calls: [] }));
-  return [
-    ...breakdown.stages.map((stage) => stage_entry(stage, report)),
-    ...notes,
-    excluded_entry(breakdown),
-    ...(breakdown.driver ?? []).map((stage) => driver_entry(stage, report))
-  ];
-}
-function bullets_of(entry) {
-  return [`- ${entry.text}`, ...[...entry.laps, ...entry.calls].map((lap) => `  - ${lap}`)];
-}
-function inline_of(entry) {
-  return entry.laps.length > 0 ? `${entry.text} [${entry.laps.join(", ")}]` : entry.text;
-}
-function report_of(issue, breakdown, entries, events = []) {
-  const calls = lane_breakdown_implement.read(issue, breakdown);
-  const rows = lane_breakdown_pinned.rows_of(entries, issue, breakdown);
-  const timing = lane_elapsed_time.of(entries, events, issue, calls);
-  return {
-    elapsed: timing === void 0 ? void 0 : lane_elapsed_time.text(timing),
-    breakdown,
-    detail: lane_breakdown_implement.of(calls, breakdown),
-    laps: lane_breakdown_laps.of(entries, issue, breakdown, calls),
-    pinned: lane_breakdown_pinned.detail_text(rows),
-    discarded: lane_breakdown_pinned.discarded_text(entries, issue),
-    related: lane_breakdown_related.over_cap_text(entries, issue),
-    critical: lane_ci_path_stats.last_check_text(entries, issue),
-    plan_calls: lane_breakdown_implement.plan_calls(calls, breakdown),
-    plan_outside: lane_breakdown_implement.plan_outside(calls, breakdown)
-  };
-}
-function comment(issue, minutes, report) {
-  const lead = `${HEADING}, ${String(minutes)} min of net time`;
-  const source = `(\`pnpm josh lane:breakdown ${String(issue)}\`):`;
-  return [
-    `${lead} ${source}`,
-    "",
-    ...entries_of(report).flatMap((entry) => bullets_of(entry)),
-    ...report.elapsed === void 0 ? [] : [report.elapsed]
-  ].join("\n");
-}
-function line(report) {
-  return `${HEADING}: ${entries_of(report).map((entry) => inline_of(entry)).join("; ")}.`;
-}
-var lane_breakdown_text = { budget_of, comment, line, report_of };
-
-export {
-  lane_breakdown_related,
-  lane_check_stats,
-  lane_ci_path_stats,
-  lane_breakdown_text
-};