@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-Z7R6JWN7.js

@@ -0,0 +1,1077 @@
+import {
+  epic_report
+} from "./chunk-4HOTJAO6.js";
+import {
+  lane_capacity
+} from "./chunk-6HJ5CJSJ.js";
+import {
+  epic_triage
+} from "./chunk-VQRT32JB.js";
+import {
+  lane_spent
+} from "./chunk-QN3FWRDW.js";
+import {
+  epic_label_age
+} from "./chunk-PLE3MBGO.js";
+import {
+  epic_fetch
+} from "./chunk-6PLIQCBG.js";
+import {
+  epic_cross_repo
+} from "./chunk-AQGVQMWF.js";
+import {
+  issue_not_before
+} from "./chunk-JUXKVN77.js";
+import {
+  issue_publication_state
+} from "./chunk-5RCBXYYD.js";
+import {
+  epic_issue
+} from "./chunk-GXXWRH6F.js";
+import {
+  issue_rank
+} from "./chunk-HLKAFSN4.js";
+import {
+  size_estimate
+} from "./chunk-IAA73DWD.js";
+import {
+  expected_effect_lint
+} from "./chunk-RETTGONB.js";
+import {
+  issue_priority
+} from "./chunk-FBWNL3UA.js";
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  epic_busy
+} from "./chunk-VRS252GW.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  lane_await
+} from "./chunk-YSDBY2G7.js";
+import {
+  lane_registry,
+  lane_snapshot_trace
+} from "./chunk-KXZR7UAE.js";
+import {
+  lane_process_table
+} from "./chunk-5QICRFVL.js";
+import {
+  lane_state
+} from "./chunk-V36OV7AP.js";
+import {
+  EPIC_LABEL,
+  IN_PROGRESS_LABEL,
+  RUN_SOLO_LABEL,
+  has_any_label,
+  has_label_name,
+  has_parked_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  issue_citation,
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  repo_discovery
+} from "./chunk-MDKDJF2K.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/epic/epic-nested.ts
+function is_nested_epic(child) {
+  return has_label_name(child.labels, EPIC_LABEL);
+}
+var epic_nested = {
+  is_nested_epic
+};
+
+// scripts/epic/epic-outside-blocker.ts
+var NOTICE_ICON = "\u2757";
+var CLOSED = "CLOSED";
+function name_of(child) {
+  return session_cite.issue(child.number, void 0, child.repo);
+}
+function as_closed_child(reference) {
+  return {
+    number: reference.number,
+    repo: reference.repo,
+    state: CLOSED,
+    labels: [],
+    blocked_by: []
+  };
+}
+function unread_answer(child, reference) {
+  const blocker = epic_graph.key_of(reference);
+  return {
+    category: "time",
+    notice: {
+      key: `unread:${epic_graph.key_of(child)}:${blocker}`,
+      message: `${NOTICE_ICON} ${name_of(child)} is blocked by ${blocker}, whose state could not be read \u2014 it waits rather than runs`
+    }
+  };
+}
+function open_answer(child, reference, running) {
+  if (running.has(epic_graph.blocker_key(reference))) return { category: "time" };
+  const blocker = epic_graph.key_of(reference);
+  return {
+    category: "human",
+    notice: {
+      key: `outside:${epic_graph.key_of(child)}:${blocker}`,
+      message: `${NOTICE_ICON} ${name_of(child)} waits on ${blocker}, which this run will not finish \u2014 withheld for a person`
+    }
+  };
+}
+function closed_category(verdict) {
+  if (verdict === "resolved") return void 0;
+  return verdict === "human" ? "human" : "time";
+}
+function outside_category(child, reference, resolve, running) {
+  if (reference.state === void 0) return unread_answer(child, reference);
+  if (reference.state !== CLOSED) return open_answer(child, reference, running);
+  return { category: closed_category(resolve(as_closed_child(reference), child)) };
+}
+function running_keys(issues) {
+  return new Set(issues.map((issue) => epic_graph.key_of(issue)));
+}
+var epic_outside_blocker = { outside_category, running_keys };
+
+// scripts/epic/epic-classify.ts
+var CLOSED2 = "CLOSED";
+function resolve_by_state(blocker) {
+  return blocker.state === CLOSED2 ? "resolved" : "inherit";
+}
+function has_label(child, label) {
+  return has_label_name(child.labels, label);
+}
+function has_human_label(child) {
+  return has_parked_label(child.labels);
+}
+function is_waiting(child) {
+  return issue_publication_state.is_pending(child.body) || has_label(child, IN_PROGRESS_LABEL) || !issue_not_before.is_due(child.body);
+}
+function local_category(child) {
+  if (child.state === CLOSED2) return "done";
+  if (epic_nested.is_nested_epic(child) || has_human_label(child)) return "human";
+  if (is_waiting(child)) return "time";
+  return void 0;
+}
+function inherited_category(blocker_category) {
+  return blocker_category === "human" ? "human" : "time";
+}
+function dependency_category(verdict, blocker_category) {
+  if (verdict === "resolved") return void 0;
+  if (verdict === "inherit") return inherited_category(blocker_category);
+  return verdict;
+}
+var reported = /* @__PURE__ */ new Set();
+function reset_reported() {
+  reported.clear();
+}
+var silence = { is_muted: false };
+function mute_notices() {
+  silence.is_muted = true;
+}
+function report_notice(notice) {
+  if (silence.is_muted || reported.has(notice.key)) return;
+  reported.add(notice.key);
+  console.warn(notice.message);
+}
+function outside_category2(child, reference, context) {
+  const answer = epic_outside_blocker.outside_category(
+    child,
+    reference,
+    context.resolve,
+    context.running
+  );
+  if (answer.notice !== void 0) report_notice(answer.notice);
+  return answer.category;
+}
+function report_nested_epic(child) {
+  const line = `epic:${epic_graph.key_of(child)}`;
+  if (reported.has(line)) return;
+  reported.add(line);
+  console.warn(
+    `\u26A0 ${epic_graph.key_of(child)} is itself an epic \u2014 a run cannot implement one, so it is withheld rather than offered`
+  );
+}
+function report_nested_epics(children) {
+  for (const child of children) {
+    if (child.state !== CLOSED2 && epic_nested.is_nested_epic(child)) report_nested_epic(child);
+  }
+}
+function relation_category(child, blocker_reference, context) {
+  const blocker = context.index.get(epic_graph.blocker_key(blocker_reference));
+  if (blocker === void 0) return outside_category2(child, blocker_reference, context);
+  return dependency_category(
+    context.resolve(blocker, child),
+    context.memo.get(epic_graph.key_of(blocker)) ?? "time"
+  );
+}
+function blocker_categories(child, context) {
+  return child.blocked_by.map((blocker) => relation_category(child, blocker, context)).filter((category) => category !== void 0);
+}
+function from_blockers(categories) {
+  if (categories.includes("human")) return "human";
+  return categories.length > 0 ? "time" : "runnable";
+}
+function compute_category(child, context) {
+  return local_category(child) ?? from_blockers(blocker_categories(child, context));
+}
+function is_ready(node, context) {
+  return epic_graph.blockers_of(context.index, node).every((blocker) => !context.index.has(blocker) || context.memo.has(blocker));
+}
+function fill_memo(children, context) {
+  const pending = new Set(children.map((child) => epic_graph.key_of(child)));
+  function peel() {
+    const ready = [...pending].filter((node) => is_ready(node, context));
+    for (const node of ready) {
+      const child = context.index.get(node);
+      if (child !== void 0) context.memo.set(node, compute_category(child, context));
+      pending.delete(node);
+    }
+    return ready.length;
+  }
+  while (peel() > 0) {
+  }
+  for (const node of pending) context.memo.set(node, "time");
+}
+function new_context(children, resolve = resolve_by_state, running = epic_outside_blocker.running_keys(children)) {
+  return {
+    index: epic_graph.index_children(children),
+    resolve,
+    memo: /* @__PURE__ */ new Map(),
+    running
+  };
+}
+function classify_children(children, resolve, running) {
+  const context = new_context(children, resolve, running);
+  const buckets = {
+    runnable: [],
+    time: [],
+    human: []
+  };
+  fill_memo(children, context);
+  report_nested_epics(children);
+  for (const child of children) {
+    const category = context.memo.get(epic_graph.key_of(child)) ?? "time";
+    if (category !== "done") buckets[category].push(child);
+  }
+  return buckets;
+}
+var epic_classify = {
+  resolve_by_state,
+  mute_notices,
+  reset_reported,
+  local_category,
+  classify_children
+};
+
+// scripts/epic/epic-candidate-confirm.ts
+var NO_ANOMALIES = 0;
+var NO_LANES = 0;
+var ONE_LANE = 1;
+function is_same_blockers(left, right) {
+  function sorted(blockers) {
+    return blockers.map((blocker) => epic_graph.key_of(blocker)).toSorted((first, second) => first.localeCompare(second)).join(",");
+  }
+  return sorted(left) === sorted(right);
+}
+function with_blockers(children, target, blocked_by) {
+  const key = epic_graph.key_of(target);
+  return children.map(
+    (child) => epic_graph.key_of(child) === key ? { ...child, blocked_by } : child
+  );
+}
+function is_still_runnable(child, children, context) {
+  const key = epic_graph.key_of(child);
+  return epic_classify.classify_children(children, context.resolve, context.running).runnable.some((candidate) => epic_graph.key_of(candidate) === key);
+}
+async function read_or_withhold(candidate, read_blockers) {
+  try {
+    return await read_blockers(candidate);
+  } catch (error) {
+    const reason = error_text.message_of(error);
+    console.warn(
+      `\u26A0 could not confirm the blockers of ${session_cite.issue(candidate.number, void 0, candidate.repo)}: ${reason}
+  it is withheld rather than offered; asking again is what resolves this`
+    );
+    return void 0;
+  }
+}
+function warn_withheld(candidate, listed) {
+  const named = listed.map((blocker) => epic_graph.key_of(blocker)).join(", ");
+  console.warn(
+    `\u26A0 ${session_cite.issue(candidate.number, void 0, candidate.repo)} is withheld: its relations listing names ${named}, which the dependency summary it was classified from did not count`
+  );
+}
+function untracked_blockers(listed, children) {
+  const index = epic_graph.index_children(children);
+  return listed.filter((blocker) => !index.has(epic_graph.blocker_key(blocker)));
+}
+function warn_untracked(candidate, untracked) {
+  const named = untracked.map((blocker) => epic_graph.key_of(blocker)).join(", ");
+  console.warn(
+    `\u26A0 ${session_cite.issue(candidate.number, void 0, candidate.repo)} is offered although its relations listing names ${named}: this epic does not track those, and every one of them is already finished`
+  );
+}
+function warn_recovered(candidate, listed, children, is_confirmed) {
+  if (!is_confirmed) {
+    warn_withheld(candidate, listed);
+    return;
+  }
+  const untracked = untracked_blockers(listed, children);
+  if (untracked.length > 0) warn_untracked(candidate, untracked);
+}
+async function confirm_one(candidate, context) {
+  const listed = await read_or_withhold(candidate, context.read_blockers);
+  if (listed === void 0) return { is_confirmed: false, children: context.children };
+  if (is_same_blockers(candidate.blocked_by, listed)) {
+    return { is_confirmed: true, children: context.children };
+  }
+  const children = with_blockers(context.children, candidate, listed);
+  const is_confirmed = is_still_runnable(candidate, children, context);
+  warn_recovered(candidate, listed, children, is_confirmed);
+  return { is_confirmed, children };
+}
+async function confirm_candidates(candidates, context, wanted) {
+  const [candidate, ...rest] = candidates;
+  if (candidate === void 0 || wanted <= NO_LANES) {
+    return { children: context.children, confirmed: [] };
+  }
+  const verdict = await confirm_one(candidate, context);
+  const taken = verdict.is_confirmed ? [candidate] : [];
+  const next = { ...context, children: verdict.children };
+  const walk = await confirm_candidates(rest, next, wanted - taken.length);
+  return { children: walk.children, confirmed: [...taken, ...walk.confirmed] };
+}
+function withheld_verdict(children, context) {
+  return epic_report.decide_verdict(
+    epic_classify.classify_children(children, context.resolve, context.running),
+    NO_ANOMALIES
+  );
+}
+async function answer_for_repo(candidates, context, wanted = ONE_LANE) {
+  const outcome = await confirm_candidates(candidates, context, wanted);
+  if (outcome.confirmed.length > NO_LANES) return { children: outcome.confirmed, verdict: "run" };
+  return { children: [], verdict: withheld_verdict(outcome.children, context) };
+}
+var epic_candidate_confirm = {
+  is_same_blockers,
+  answer_for_repo
+};
+
+// scripts/backlog/backlog-occupied.ts
+function is_never_merge_waiting() {
+  return false;
+}
+function occupied_lanes(lanes, idle, records, is_merge_waiting = is_never_merge_waiting) {
+  const live = lanes.filter((lane) => !lane.is_stranded);
+  const idle_issues = new Set(idle(live));
+  return live.filter((lane) => {
+    const state = records.get(lane.issue)?.state;
+    return !idle_issues.has(lane.issue) && state !== "paused" && !is_merge_waiting(lane.issue);
+  });
+}
+function unknown_lanes(lanes, records) {
+  return lanes.filter((lane) => !lane.is_stranded && !records.has(lane.issue)).map((lane) => lane.issue);
+}
+var backlog_occupied = { occupied_lanes, unknown_lanes };
+
+// scripts/lane/lane-room.ts
+async function occupancy_of(open, table) {
+  const rows = await table();
+  const issues = open.map((lane) => lane.issue);
+  const trace = { process_trace: await lane_snapshot_trace.traces_of(issues, rows) };
+  const records = await lane_state.read_states(issues);
+  const is_merge_waiting = await lane_snapshot_trace.merge_waits_of(issues, rows);
+  const occupied = backlog_occupied.occupied_lanes(
+    open,
+    (live) => lane_spent.idle_lanes(live, trace),
+    records,
+    is_merge_waiting
+  );
+  const unknown = backlog_occupied.unknown_lanes(open, records);
+  return { occupied, idle: lane_spent.idle_lanes(open, trace), unknown };
+}
+async function read(lanes, table = lane_process_table.read_table) {
+  const open = lanes ?? await lane_registry.list_lanes();
+  const occupancy = await occupancy_of(open, table);
+  const seated = lane_registry.used_seats(open).length;
+  const use = { occupied: occupancy.occupied.length, seated, unknown: occupancy.unknown };
+  return { ...occupancy, use };
+}
+var lane_room = { read };
+
+// scripts/epic/epic-lane-occupancy.ts
+var SOLO_LABELS = /* @__PURE__ */ new Set([RUN_SOLO_LABEL]);
+function is_local(issue, lanes) {
+  return lanes.some((lane) => lane.issue === String(issue.number));
+}
+function confirmed_stopped(lanes, room) {
+  const occupied = new Set(room.occupied.map((lane) => lane.issue));
+  return new Set(
+    lanes.filter((lane) => !lane.seat_held && lane.seat_problem === void 0).map((lane) => lane.issue).filter(
+      (issue) => room.idle.includes(issue) && !room.unknown.includes(issue) && !occupied.has(issue)
+    )
+  );
+}
+function reconcile(issues, lanes, room) {
+  const stopped = confirmed_stopped(lanes, room);
+  const holders = issues.filter(
+    (issue) => has_any_label(issue.labels, SOLO_LABELS) || !stopped.has(String(issue.number))
+  );
+  const remote = holders.filter((issue) => !is_local(issue, lanes)).length;
+  const occupied = new Set(room.occupied.map((lane) => lane.issue));
+  const unknown = holders.filter(
+    (issue) => room.unknown.includes(String(issue.number)) && !occupied.has(String(issue.number))
+  ).length;
+  const use = {
+    ...room.use,
+    occupied: room.use.occupied + remote + unknown,
+    seated: room.use.seated + remote
+  };
+  return { read: holders.length > 0 ? { kind: "busy", issues: holders } : { kind: "idle" }, use };
+}
+async function read2(reading, is_this_checkout) {
+  if (!is_this_checkout || reading.kind !== "busy") return { read: reading };
+  try {
+    const lanes = await lane_registry.list_lanes();
+    if (reading.issues.every((issue) => !is_local(issue, lanes))) return { read: reading };
+    return reconcile(reading.issues, lanes, await lane_room.read(lanes));
+  } catch {
+    return { read: reading };
+  }
+}
+var epic_lane_occupancy = { read: read2 };
+
+// scripts/epic/epic-rank.ts
+var CLOSED3 = "CLOSED";
+function dependents_of(pool) {
+  return issue_rank.count_dependents(
+    pool.filter((child) => child.state !== CLOSED3).map((child) => ({
+      key: epic_graph.key_of(child),
+      blockers: child.blocked_by.map((blocker) => epic_graph.blocker_key(blocker))
+    }))
+  );
+}
+function rank(children, pool) {
+  const dependents = dependents_of(pool);
+  return issue_rank.rank(children, (child) => ({
+    is_resumable: child.is_resumable,
+    is_last: issue_priority.is_last(child.body),
+    labels: child.labels,
+    lost_minutes: issue_priority.lost_minutes(child.body),
+    gain_minutes: expected_effect_lint.weekly_minutes(child.body),
+    dependents: dependents.get(epic_graph.key_of(child)) ?? 0,
+    estimated_lines: size_estimate.declared_size(child.body ?? "")?.lines
+  }));
+}
+var epic_rank = { rank };
+
+// scripts/epic/epic-solo.ts
+function is_solo(child) {
+  return has_label_name(child.labels, RUN_SOLO_LABEL);
+}
+function holder_of(running) {
+  return running.find((issue) => is_solo(issue))?.number;
+}
+function solo_holder(read3) {
+  if (read3.kind !== "busy") return void 0;
+  const running = read3.issues.map((issue) => ({
+    number: issue.number,
+    labels: (issue.labels ?? []).map((label) => label.name)
+  }));
+  return holder_of(running);
+}
+var HELD_MARK = `carries \`${RUN_SOLO_LABEL}\` and is running in`;
+var WAITING_MARK = `carries \`${RUN_SOLO_LABEL}\` and waits for`;
+function held_message(holder, repo) {
+  return issue_citation.linkify(
+    `${issue_cite.plain_for("linked", holder)} ${HELD_MARK} ${repo}; nothing else starts until it merges or is parked.`,
+    repo
+  );
+}
+function waiting_message(solo, repo) {
+  return issue_citation.linkify(
+    `${issue_cite.plain_for("linked", solo)} ${WAITING_MARK} ${repo}'s running lanes to finish; nothing ranked below it is offered past it.`,
+    repo
+  );
+}
+function is_solo_wait(text) {
+  return text.includes(HELD_MARK) || text.includes(WAITING_MARK);
+}
+function first_of(children, keep) {
+  return { offered: children.slice(0, keep), withheld: children.slice(keep) };
+}
+function none_of(children, notice) {
+  return { offered: [], withheld: [...children], notice };
+}
+function queue_of(children) {
+  const index = children.findIndex((child) => is_solo(child));
+  const solo = children[index];
+  return solo === void 0 ? void 0 : { solo, index, behind: children.slice(index + 1) };
+}
+function select_candidates(children, read3, repo, occupied) {
+  const queue = queue_of(children);
+  if (queue === void 0) return first_of(children, children.length);
+  if (queue.index > 0) return first_of(children, queue.index);
+  if (occupied === 0 && read3.kind === "idle") return first_of(children, 1);
+  return none_of(children, waiting_message(queue.solo.number, repo));
+}
+function select(children, read3, repo, occupied = epic_busy.occupied_lanes(read3)) {
+  if (read3.kind === "unreadable" || read3.kind === "truncated") {
+    return none_of(children, epic_busy.busy_reason(read3, repo, 0));
+  }
+  const holder = solo_holder(read3);
+  if (holder !== void 0) return none_of(children, held_message(holder, repo));
+  return select_candidates(children, read3, repo, occupied);
+}
+function withhold(result, repo, selection) {
+  return {
+    ...result,
+    candidates: result.candidates.map(
+      (bundle) => bundle.repo === repo ? { ...bundle, children: selection.offered } : bundle
+    ),
+    waiting: [...result.waiting, ...selection.withheld]
+  };
+}
+function gate(result, read3, repo, selector = select) {
+  if (result.verdict !== "run") return { result };
+  const selection = selector(epic_report.candidates_for_repo(result, repo), read3, repo);
+  const gated = withhold(result, repo, selection);
+  return selection.notice === void 0 ? { result: gated } : { result: gated, notice: selection.notice };
+}
+var epic_solo = { gate, holder_of, is_solo, is_solo_wait, queue_of, select };
+
+// scripts/epic/epic-solo-stale.ts
+import { setTimeout as sleep } from "node:timers/promises";
+var SOLO_LABELS2 = /* @__PURE__ */ new Set([RUN_SOLO_LABEL]);
+function is_absent_solo(issue) {
+  if (!has_any_label(issue.labels, SOLO_LABELS2)) return false;
+  return !lane_await.is_process_running_default(String(issue.number));
+}
+async function local_lanes() {
+  try {
+    const lanes = await lane_registry.list_lanes();
+    return new Set(lanes.map((lane) => lane.issue));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function settle() {
+  await sleep(lane_await.RECONFIRM_MS);
+}
+var io = { local_lanes, settle };
+async function find_stale(issues) {
+  const absent = issues.filter((issue) => is_absent_solo(issue));
+  if (absent.length === 0) return [];
+  const lanes = await io.local_lanes();
+  const dispatched = absent.filter((issue) => lanes.has(String(issue.number)));
+  if (dispatched.length === 0) return [];
+  await io.settle();
+  return dispatched.filter((issue) => is_absent_solo(issue));
+}
+function stale_message(stale, repo) {
+  const named = stale.map((issue) => issue_cite.plain_for("linked", issue.number)).join(", ");
+  return issue_citation.linkify(
+    `${named} carries \`${RUN_SOLO_LABEL}\` and \`${IN_PROGRESS_LABEL}\`, but no process of it is running in ${repo} \u2014 the \`${IN_PROGRESS_LABEL}\` label is stale, so it does not hold the backlog. Remove the label once you have confirmed nothing is running it.`,
+    repo
+  );
+}
+async function release(read3, repo) {
+  if (read3.kind !== "busy") return { read: read3 };
+  const stale = await find_stale(read3.issues);
+  if (stale.length === 0) return { read: read3 };
+  const holders = read3.issues.filter((issue) => !stale.includes(issue));
+  const released = holders.length > 0 ? { kind: "busy", issues: holders } : { kind: "idle" };
+  return { read: released, notice: stale_message(stale, repo) };
+}
+var epic_solo_stale = { io, release };
+
+// scripts/epic/epic-lane-offer.ts
+var WAIT_VERDICT = "wait";
+var RUN_VERDICT = "run";
+var NO_LANES2 = 0;
+var ONE_LANE2 = 1;
+function is_held(read3) {
+  return read3.kind === "unreadable" || read3.kind === "truncated";
+}
+function free_lanes(read3, limit, merge_waiting) {
+  if (is_held(read3)) return NO_LANES2;
+  const holders = epic_busy.occupied_lanes(read3);
+  return lane_capacity.free_lanes(limit, holders - merge_waiting, holders);
+}
+async function merge_waiting_holders(read3, request) {
+  if (read3.kind !== "busy" || !request.is_this_checkout) return NO_LANES2;
+  return await lane_snapshot_trace.count_merge_waiting(
+    read3.issues.map((issue) => String(issue.number))
+  );
+}
+async function room_in(occupancy, request) {
+  if (occupancy.use !== void 0) {
+    return lane_capacity.free_lanes(request.limit, occupancy.use.occupied, occupancy.use.seated);
+  }
+  return free_lanes(
+    occupancy.read,
+    request.limit,
+    await merge_waiting_holders(occupancy.read, request)
+  );
+}
+function wanted_of(request, free) {
+  return request.is_all_lanes ? free : Math.min(ONE_LANE2, free);
+}
+function withheld_message(repo) {
+  return `No runnable child in ${repo}: every candidate was withheld when its blocker relations were confirmed \u2014 the reason for each is above.`;
+}
+function offered_notice(children, read3, request, ages) {
+  if (children.length === NO_LANES2) return withheld_message(request.repo);
+  if (read3.kind !== "busy") return "";
+  return epic_busy.occupancy_message(read3.issues, request.repo, request.limit, ages);
+}
+async function holder_ages(read3, repo) {
+  if (read3.kind !== "busy") return /* @__PURE__ */ new Map();
+  return await epic_label_age.read_ages(
+    read3.issues.map((issue) => issue.number),
+    repo,
+    /* @__PURE__ */ new Date()
+  );
+}
+var VERDICT_PRIORITY = [RUN_VERDICT, WAIT_VERDICT, "stop", "complete"];
+function combine_verdicts(left, right) {
+  return VERDICT_PRIORITY.indexOf(left) <= VERDICT_PRIORITY.indexOf(right) ? left : right;
+}
+function candidates_in(pool, repo) {
+  return { ...pool, candidates: pool.candidates.filter((child) => child.repo === repo) };
+}
+function ranked_in(pool, repo) {
+  const scoped = candidates_in(pool, repo);
+  return { ...scoped, candidates: epic_rank.rank(scoped.candidates, pool.context.children) };
+}
+function unseen_candidates(pool, seen) {
+  const candidates = [];
+  for (const child of pool.candidates) {
+    const key = epic_graph.key_of(child);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    candidates.push(child);
+  }
+  return { ...pool, candidates };
+}
+function dedupe_pools(pools) {
+  const seen = /* @__PURE__ */ new Set();
+  return pools.map((pool) => unseen_candidates(pool, seen));
+}
+async function ask_pool(pool, wanted) {
+  return await epic_candidate_confirm.answer_for_repo(pool.candidates, pool.context, wanted);
+}
+async function collect(pools, wanted) {
+  const children = [];
+  let verdict = "complete";
+  for (const pool of pools) {
+    if (children.length >= wanted) break;
+    const answer = await ask_pool(pool, wanted - children.length);
+    children.push(...answer.children);
+    verdict = combine_verdicts(verdict, answer.verdict);
+  }
+  return { children, verdict: children.length > NO_LANES2 ? RUN_VERDICT : verdict };
+}
+function solo_offer(answer, occupancy, request, ages) {
+  const { read: read3, use } = occupancy;
+  const { offered, notice = "" } = epic_solo.select(
+    answer.children,
+    read3,
+    request.repo,
+    use?.occupied
+  );
+  if (offered.length === NO_LANES2 && answer.children.length > NO_LANES2) {
+    return { children: [], verdict: WAIT_VERDICT, notice };
+  }
+  return { ...answer, children: offered, notice: offered_notice(offered, read3, request, ages) };
+}
+function triage_offer(pools, request) {
+  if (!request.is_all_lanes) return void 0;
+  const untriaged = epic_triage.untriaged(
+    dedupe_pools(pools.map((pool) => candidates_in(pool, request.repo))).flatMap(
+      (pool) => pool.candidates
+    )
+  );
+  if (untriaged.length === NO_LANES2) return void 0;
+  return {
+    children: [],
+    verdict: epic_triage.TRIAGE_VERDICT,
+    notice: epic_triage.message(untriaged, request.repo)
+  };
+}
+function full_notice(occupancy, request, ages) {
+  if (occupancy.use === void 0) {
+    return epic_busy.busy_reason(occupancy.read, request.repo, request.limit, ages);
+  }
+  return `${String(occupancy.use.occupied)} of ${String(request.limit)} lanes in use in ${request.repo}; ${String(occupancy.use.seated)} port seats held. No lane is free, so nothing is offered here.`;
+}
+async function offer_after_triage(pools, request) {
+  const released = await epic_solo_stale.release(
+    await epic_busy.read_repository(request.repo),
+    request.repo
+  );
+  if (released.notice !== void 0) console.error(released.notice);
+  const occupancy = await epic_lane_occupancy.read(released.read, request.is_this_checkout);
+  const { read: read3 } = occupancy;
+  const free = await room_in(occupancy, request);
+  const ages = await holder_ages(read3, request.repo);
+  if (free === NO_LANES2) {
+    return {
+      children: [],
+      verdict: WAIT_VERDICT,
+      notice: full_notice(occupancy, request, ages)
+    };
+  }
+  const for_repo = dedupe_pools(pools.map((pool) => ranked_in(pool, request.repo)));
+  return solo_offer(await collect(for_repo, wanted_of(request, free)), occupancy, request, ages);
+}
+async function offer_for_repo(pools, request) {
+  return triage_offer(pools, request) ?? await offer_after_triage(pools, request);
+}
+function lane_request(asked, limit, current_repo) {
+  const is_this_checkout = asked.repo.toLowerCase() === current_repo.toLowerCase();
+  return { ...asked, limit, is_this_checkout };
+}
+var epic_lane_offer = {
+  combine_verdicts,
+  dedupe_pools,
+  lane_request,
+  offer_for_repo
+};
+
+// scripts/epic/epic-next-read.ts
+var FOREIGN_EPIC = "That epic belongs to another owner; this command only reads our own.";
+var NO_CHILDREN = 0;
+function epic_repo_of(reference, current_repo) {
+  const epic_repo = reference.repo ?? current_repo;
+  const owner = epic_cross_repo.owner_of(current_repo);
+  return epic_cross_repo.is_same_owner_repo(epic_repo, owner) ? epic_repo : void 0;
+}
+function childless(reference) {
+  return `${session_cite.issue(reference.number, void 0, reference.repo)} tracks no children in a task list.`;
+}
+function unique_references(references, current_repo) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const reference of references) {
+    const repo = reference.repo ?? current_repo;
+    const key = epic_graph.key_of({ repo, number: reference.number });
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(reference);
+  }
+  return unique;
+}
+function is_childless(snapshot) {
+  if (snapshot.body_failure !== void 0) return false;
+  return snapshot.child_numbers.length === NO_CHILDREN;
+}
+async function read_one(reference, current_repo, source) {
+  const epic_repo = epic_repo_of(reference, current_repo);
+  if (epic_repo === void 0) return { refusal: FOREIGN_EPIC };
+  const snapshot = await epic_fetch.fetch_epic(reference.number, epic_repo, current_repo, source);
+  if (is_childless(snapshot)) return { notice: childless(reference) };
+  return { read: { reference, snapshot } };
+}
+function collect2(outcome, reads, notices) {
+  if (outcome.read !== void 0) reads.push(outcome.read);
+  if (outcome.notice !== void 0) notices.push(outcome.notice);
+}
+async function read_snapshots(references, current_repo, source) {
+  const reads = [];
+  const notices = [];
+  for (const reference of unique_references(references, current_repo)) {
+    const outcome = await read_one(reference, current_repo, source);
+    if (outcome.refusal !== void 0) return { reads, notices, refusal: outcome.refusal };
+    collect2(outcome, reads, notices);
+  }
+  return { reads, notices };
+}
+var epic_next_read = {
+  FOREIGN_EPIC,
+  childless,
+  unique_references,
+  read_snapshots
+};
+
+// scripts/epic/epic-next-views.ts
+var COMPLETE_VERDICT = "complete";
+var ERROR_VERDICT = "error";
+var ONE_EPIC = 1;
+var BLOCK_SEPARATOR = "\n\n";
+function format_reference(reference) {
+  return issue_cite.plain_for("linked", reference.number, reference.repo);
+}
+function confirm_context(snapshot, running) {
+  return {
+    children: snapshot.children,
+    running,
+    resolve: epic_cross_repo.resolve_cross_repo,
+    read_blockers: async (child) => await epic_fetch.read_child_blockers(child, snapshot.current_repo)
+  };
+}
+function pools_of(views, repo) {
+  return views.map((view) => ({
+    candidates: epic_report.candidates_for_repo(view.result, repo),
+    context: confirm_context(view.snapshot, view.running)
+  }));
+}
+function combined_verdict(views) {
+  let verdict = COMPLETE_VERDICT;
+  for (const view of views) verdict = epic_lane_offer.combine_verdicts(verdict, view.result.verdict);
+  return verdict;
+}
+function error_view(views) {
+  return views.find((view) => view.result.verdict === ERROR_VERDICT);
+}
+function format_view(view, is_many, current_repo) {
+  const text = epic_report.format_result(view.result, current_repo);
+  return is_many ? `${format_reference(view.reference)}
+${text}` : text;
+}
+function aggregate_text(views, current_repo) {
+  const is_many = views.length > ONE_EPIC;
+  return views.map((view) => format_view(view, is_many, current_repo)).join(BLOCK_SEPARATOR);
+}
+function settle_views(running, build) {
+  const views = build(running);
+  const stuck = new Set(
+    views.flatMap((view) => view.result.blocked_on_people.map((child) => epic_graph.key_of(child)))
+  );
+  const settled = new Set(running);
+  for (const key of stuck) settled.delete(key);
+  return settled.size === running.size ? views : settle_views(settled, build);
+}
+var epic_next_views = {
+  settle_views,
+  format_reference,
+  pools_of,
+  combined_verdict,
+  error_view,
+  format_view,
+  aggregate_text
+};
+
+// scripts/epic/epic-next.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var OPTIONS = { repo: { type: "string" }, lanes: { type: "boolean" } };
+var USAGE = "Usage: josh epic:next <epic-number|owner/repo#number>... [--repo <owner/repo>] [--lanes]";
+var UNKNOWN_REPO = "Could not read this repository from `git remote`, so the children cannot be keyed by repository \u2014 check `gh auth status` and that this is a checkout with an `origin` remote.";
+var EXTERNAL_NOTICE = "Note: this epic tracks children in other repositories.";
+var { FOREIGN_EPIC: FOREIGN_EPIC2 } = epic_next_read;
+var NO_CHILDREN2 = 0;
+var ONE_EPIC2 = 1;
+var UNCHECKED_EXCLUSION = "Note: the per-repository lane count is applied by `--repo`; a child listed here may still be held back there while every lane is in use.";
+function parse_references(head) {
+  const references = [];
+  for (const entry of head) {
+    const reference = epic_issue.parse_epic_reference(entry);
+    if (reference === void 0) return void 0;
+    references.push(reference);
+  }
+  return references.length === 0 ? void 0 : references;
+}
+function with_repo(references, values) {
+  const { repo, lanes: is_all_lanes = false } = values;
+  if (repo === void 0) return is_all_lanes ? { usage: USAGE } : { references };
+  return { references, repo, is_all_lanes };
+}
+function parse_options(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return { usage: USAGE };
+  const references = parse_references(parsed.positionals);
+  if (references === void 0 || parsed.values.repo === "") return { usage: USAGE };
+  return with_repo(references, parsed.values);
+}
+function body_anomaly(snapshot) {
+  if (snapshot.body_failure === void 0) return void 0;
+  return {
+    kind: "unreadable_epic_body",
+    message: `Could not read the body of the epic in ${snapshot.repo}. Its task list is what names the children, so nothing is offered \u2014 check \`gh auth status\` and that the epic exists.`,
+    is_unreachable: snapshot.is_unreachable
+  };
+}
+function unreadable_anomaly(snapshot) {
+  const missing = epic_fetch.missing_children(snapshot);
+  if (missing.length === 0) return void 0;
+  const list = epic_graph.format_references(missing, snapshot.current_repo);
+  return {
+    kind: "unreadable_children",
+    message: `Could not read ${list}. The dependency graph would be missing them, so nothing is offered \u2014 check \`gh auth status\` and that the issues exist.`,
+    is_unreachable: snapshot.is_unreachable
+  };
+}
+function is_order_declared(body, links) {
+  return links.length > 0 || epic_parse.has_unordered_declaration(body);
+}
+function decide(snapshot, paths = /* @__PURE__ */ new Map(), running) {
+  const links = epic_parse.parse_dependency_links(snapshot.body);
+  const unreadable = body_anomaly(snapshot) ?? unreadable_anomaly(snapshot);
+  const anomalies = unreadable === void 0 ? epic_graph.find_anomalies(
+    snapshot.children,
+    links,
+    is_order_declared(snapshot.body, links),
+    snapshot.repo
+  ) : [unreadable];
+  const classification = epic_classify.classify_children(
+    snapshot.children,
+    epic_cross_repo.resolve_cross_repo,
+    running
+  );
+  return epic_report.build_result(classification, anomalies, paths);
+}
+function refuse(reason) {
+  console.error(reason);
+  return FAILURE_EXIT_CODE;
+}
+function repo_verdict(verdict) {
+  return verdict === "run" ? "wait" : verdict;
+}
+function report_offer(offer) {
+  if (offer.notice !== "") console.error(offer.notice);
+  if (offer.children.length === NO_CHILDREN2) {
+    console.info(repo_verdict(offer.verdict));
+    return SUCCESS_EXIT_CODE;
+  }
+  for (const child of offer.children) console.info(String(child.number));
+  return SUCCESS_EXIT_CODE;
+}
+async function offer_children(views, request) {
+  const pools = epic_next_views.pools_of(views, request.repo);
+  return report_offer(await epic_lane_offer.offer_for_repo(pools, request));
+}
+async function report_single(views, request) {
+  const broken = epic_next_views.error_view(views);
+  if (broken !== void 0) {
+    return refuse(epic_next_views.format_view(broken, views.length > ONE_EPIC2, request.repo));
+  }
+  const has_candidate = views.some(
+    (view) => epic_report.candidates_for_repo(view.result, request.repo).length > NO_CHILDREN2
+  );
+  if (!has_candidate) {
+    console.error(`No runnable child in ${request.repo}.`);
+    console.info(repo_verdict(epic_next_views.combined_verdict(views)));
+    return SUCCESS_EXIT_CODE;
+  }
+  return await offer_children(views, request);
+}
+function note_unchecked_exclusion(views) {
+  if (epic_next_views.combined_verdict(views) === "run") console.error(UNCHECKED_EXCLUSION);
+}
+function report_aggregate(views, current_repo) {
+  note_unchecked_exclusion(views);
+  const text = epic_next_views.aggregate_text(views, current_repo);
+  if (epic_next_views.error_view(views) !== void 0) {
+    console.error(text);
+    return FAILURE_EXIT_CODE;
+  }
+  console.info(issue_citation.linkify(text, current_repo));
+  return SUCCESS_EXIT_CODE;
+}
+function external_notice(view, is_many) {
+  return is_many ? `${epic_next_views.format_reference(view.reference)} ${EXTERNAL_NOTICE}` : EXTERNAL_NOTICE;
+}
+function note_external(views) {
+  const is_many = views.length > ONE_EPIC2;
+  for (const view of views) {
+    if (view.snapshot.has_external_children) console.error(external_notice(view, is_many));
+  }
+}
+async function report(views, request, current_repo) {
+  note_external(views);
+  if (request !== void 0) return await report_single(views, request);
+  return report_aggregate(views, current_repo);
+}
+async function report_epics(views, options, current_repo) {
+  if (options.repo === void 0) return await report(views, void 0, current_repo);
+  const choice = await lane_capacity.lane_limit();
+  if (choice.kind === "problem") return refuse(choice.problem);
+  const request = epic_lane_offer.lane_request(
+    { repo: options.repo, is_all_lanes: options.is_all_lanes ?? false },
+    choice.limit,
+    current_repo
+  );
+  return await report(views, request, current_repo);
+}
+function views_of(reads, running = epic_outside_blocker.running_keys(reads.flatMap((read3) => read3.snapshot.children))) {
+  const paths = repo_discovery.discover_repositories(PROJECT_ROOT);
+  epic_cross_repo.reset_publish_cache();
+  epic_classify.reset_reported();
+  return epic_next_views.settle_views(
+    running,
+    (settled) => reads.map((read3) => ({
+      ...read3,
+      running: settled,
+      result: decide(read3.snapshot, paths, settled)
+    }))
+  );
+}
+function refuse_reads(result) {
+  if (result.refusal !== void 0) return refuse(result.refusal);
+  if (result.reads.length === NO_CHILDREN2) return refuse(result.notices.join("\n"));
+  for (const notice of result.notices) console.error(notice);
+  return void 0;
+}
+async function run_epics(options) {
+  const references = options.references ?? [];
+  if (references.length === NO_CHILDREN2) return refuse(USAGE);
+  const current_repo = await git_gh_command.repo_get_name_with_owner();
+  if (current_repo === void 0) return refuse(UNKNOWN_REPO);
+  const result = await epic_next_read.read_snapshots(references, current_repo);
+  const stopped = refuse_reads(result);
+  return stopped ?? await report_epics(views_of(result.reads), options, current_repo);
+}
+async function run(argv) {
+  const options = parse_options(argv);
+  if (options.references === void 0) {
+    console.error(options.usage ?? USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return await run_epics(options);
+}
+var epic_next = {
+  EXTERNAL_NOTICE,
+  FOREIGN_EPIC: FOREIGN_EPIC2,
+  is_order_declared,
+  repo_verdict,
+  UNCHECKED_EXCLUSION,
+  parse_options,
+  refuse_reads,
+  views_of,
+  run,
+  run_epics,
+  decide,
+  report
+};
+
+export {
+  lane_room,
+  epic_nested,
+  epic_outside_blocker,
+  epic_classify,
+  epic_rank,
+  epic_solo,
+  epic_solo_stale,
+  epic_next_read,
+  epic_next
+};