@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/dist/commands/chunk-RINVPTA2.js

@@ -0,0 +1,1310 @@
+import {
+  stash_orphans
+} from "./chunk-FNOSSXLG.js";
+import {
+  lane_net_read
+} from "./chunk-VZSJCFRT.js";
+import {
+  epic_next,
+  epic_next_read,
+  epic_outside_blocker,
+  epic_rank,
+  epic_report,
+  epic_solo,
+  epic_solo_stale
+} from "./chunk-PWYXY46Y.js";
+import {
+  epic_triage
+} from "./chunk-AM44D7NF.js";
+import {
+  epic_cross_repo
+} from "./chunk-P4O67FP5.js";
+import {
+  backlog_plan_comment
+} from "./chunk-F3WBEEYC.js";
+import {
+  auto_ok_author,
+  auto_ok_cli,
+  epic_bundle_gaps
+} from "./chunk-F2J6DGDM.js";
+import {
+  epic_index
+} from "./chunk-ZQ3CKRMP.js";
+import {
+  issue_not_before
+} from "./chunk-M42SLJCD.js";
+import {
+  run_prep_locate
+} from "./chunk-A4HOQKOG.js";
+import {
+  defect_rate,
+  issue_search
+} from "./chunk-QA22PBCJ.js";
+import {
+  issue_sample_prime
+} from "./chunk-NGKB632X.js";
+import {
+  epic_issue
+} from "./chunk-LC7SBONO.js";
+import {
+  git_next_issues
+} from "./chunk-ELWNRE6E.js";
+import {
+  size_estimate
+} from "./chunk-7ZECP3J6.js";
+import {
+  split_assess
+} from "./chunk-5PAEXYIY.js";
+import {
+  epic_audit_logic
+} from "./chunk-OJ4LGBVD.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  epic_busy
+} from "./chunk-LE7TFPMU.js";
+import {
+  git_gh_command
+} from "./chunk-RX5JSPPH.js";
+import {
+  git_gh_issue_write
+} from "./chunk-U2UH4VM4.js";
+import {
+  backlog_overlap,
+  lane_plan
+} from "./chunk-4Z5723GA.js";
+import {
+  git_stash
+} from "./chunk-L6XN3EXI.js";
+import {
+  issue_body_keys
+} from "./chunk-FNQW6NY7.js";
+import {
+  git_gh_issue_read
+} from "./chunk-LRA3PXHS.js";
+import {
+  GRAPHQL_PATH
+} from "./chunk-TVZXG4Y4.js";
+import {
+  shared_cache
+} from "./chunk-C6QSVO5K.js";
+import {
+  lane_state
+} from "./chunk-5Y7QQYTU.js";
+import {
+  epic_issue_schema
+} from "./chunk-34DND4BA.js";
+import {
+  BUG_LABEL,
+  EPIC_LABEL,
+  IN_PROGRESS_LABEL,
+  NOT_BEFORE_LABEL,
+  PARKED_LABELS,
+  REPOSITORY_LABELS,
+  RUN_LANE_LABEL,
+  SPLIT_ROUTE_LABEL,
+  has_any_label,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  issue_citation,
+  session_cite
+} from "./chunk-X7PN54LZ.js";
+import {
+  repo_discovery
+} from "./chunk-MDKDJF2K.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  lane_ledger_write
+} from "./chunk-I63RNFFR.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec,
+  parse_json_array_or_undefined,
+  parse_json_object_or_undefined
+} from "./chunk-XDF25GSU.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  line_budget
+} from "./chunk-UEURNXE5.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/issue/issue-not-before-label.ts
+var DEFINITION = REPOSITORY_LABELS.find((label) => label.name === NOT_BEFORE_LABEL);
+var NOT_APPLIED = "the label was not applied";
+var LABELLED_LIMIT = 200;
+function is_waiting(body, now) {
+  return !issue_not_before.is_due(body, now);
+}
+function change_of(body, labels, now = Date.now()) {
+  const is_labelled = has_label_name(labels, NOT_BEFORE_LABEL);
+  if (is_waiting(body, now) === is_labelled) return void 0;
+  return is_labelled ? "remove" : "add";
+}
+function with_label(labels, body, now = Date.now()) {
+  return change_of(body, labels, now) === "add" ? [...labels, NOT_BEFORE_LABEL] : labels;
+}
+function changes_of(issues, now) {
+  return issues.flatMap(function change(issue) {
+    const names = (issue.labels ?? []).map((label) => label.name);
+    const owed = change_of(issue.body, names, now);
+    return owed === void 0 ? [] : [[issue, owed]];
+  });
+}
+async function write(number, owed) {
+  if (owed === "remove") {
+    await git_gh_issue_write.issue_remove_label(number, NOT_BEFORE_LABEL);
+    return;
+  }
+  if (!await git_gh_issue_write.issue_add_label(number, NOT_BEFORE_LABEL)) {
+    throw new Error(NOT_APPLIED);
+  }
+}
+async function apply(issue, owed) {
+  try {
+    await write(String(issue.number), owed);
+  } catch (error) {
+    const cited2 = session_cite.issue(issue.number);
+    console.warn(
+      `${cited2}: could not ${owed} \`${NOT_BEFORE_LABEL}\`: ${error_text.message_of(error)}`
+    );
+  }
+}
+async function sync(issues, now = Date.now()) {
+  const changes = changes_of(issues, now);
+  if (DEFINITION !== void 0 && changes.some(([, owed]) => owed === "add")) {
+    await git_gh_issue_write.label_ensure(DEFINITION);
+  }
+  await Promise.all(
+    changes.map(async ([issue, owed]) => {
+      await apply(issue, owed);
+    })
+  );
+}
+async function read_labelled() {
+  const { json } = await git_gh_command.issue_list_by_label(NOT_BEFORE_LABEL, LABELLED_LIMIT);
+  const rows = json === void 0 ? void 0 : parse_json_array_or_undefined(json, epic_issue_schema);
+  return (rows ?? []).map((row) => ({ ...row, labels: [{ name: NOT_BEFORE_LABEL }] }));
+}
+async function sweep(scanned, now = Date.now()) {
+  const seen = new Set(scanned.map((issue) => issue.number));
+  const labelled = await read_labelled();
+  await issue_sample_prime.prime(labelled.map((issue) => issue.body));
+  await sync([...scanned, ...labelled.filter((issue) => !seen.has(issue.number))], now);
+}
+var issue_not_before_label = { change_of, sweep, sync, with_label };
+
+// scripts/backlog/backlog-auto-triage.ts
+var GATE_PATHS = [
+  "eslint/",
+  "eslint.config",
+  "scripts/hooks/",
+  "scripts/gate/",
+  "scripts/lint/",
+  "scripts/review/",
+  "scripts/ci/",
+  "prompts/review",
+  "lefthook",
+  ".github/workflows/",
+  "vitest.config",
+  "tsconfig",
+  "cspell.config"
+];
+function names_gate_path(body) {
+  return GATE_PATHS.some((path2) => body.includes(path2));
+}
+function lane_reason(child) {
+  if (!has_label_name(child.labels, BUG_LABEL)) return `it carries no \`${BUG_LABEL}\` label`;
+  if (child.body === void 0 || names_gate_path(child.body)) return void 0;
+  return `it is a \`${BUG_LABEL}\`, but its body names no verification-gate path`;
+}
+function comment_of(reason) {
+  return [
+    `Triaged mechanically to \`${RUN_LANE_LABEL}\`: ${reason}.`,
+    '`run:solo` needs all three conditions of `backlogrun-lanes.md` \u2192 "A solo run", so no judgment session was woken.'
+  ].join("\n");
+}
+async function decided_labels(child, repo) {
+  const reason = lane_reason(child);
+  if (reason === void 0) return void 0;
+  const issue = String(child.number);
+  const current = await git_gh_command.read_label_names(issue, repo);
+  if (current === void 0 || epic_triage.has_triage_label(current)) return current;
+  const write2 = await git_gh_command.issue_apply_label(issue, RUN_LANE_LABEL, repo);
+  if (!write2.is_applied) return void 0;
+  await git_gh_command.issue_try_comment(issue, comment_of(reason), repo);
+  return [...current, RUN_LANE_LABEL];
+}
+async function settle_child(child, repo) {
+  if (epic_triage.is_triaged(child)) return child;
+  const labels = await decided_labels(child, repo);
+  return labels === void 0 ? child : { ...child, labels };
+}
+async function settle_children(children, repo) {
+  return await Promise.all(children.map(async (child) => await settle_child(child, repo)));
+}
+async function settle(result, repo) {
+  if (result.verdict !== "run") return result;
+  const candidates = await Promise.all(
+    result.candidates.map(
+      async (bucket) => bucket.repo === repo ? { ...bucket, children: await settle_children(bucket.children, repo) } : bucket
+    )
+  );
+  return { ...result, candidates };
+}
+async function untriaged_of(result, repo) {
+  const settled = await settle(result, repo);
+  if (settled.verdict !== "run") return { result: settled, untriaged: [] };
+  return {
+    result: settled,
+    untriaged: epic_triage.untriaged(epic_report.candidates_for_repo(settled, repo))
+  };
+}
+var backlog_auto_triage = { lane_reason, untriaged_of };
+
+// scripts/issue/defect-rate-cli.ts
+import { z } from "zod";
+var MS_PER_MINUTE = 6e4;
+var CACHE_TTL_MINUTES = 15;
+var RATE_CACHE = {
+  prefix: "josh-defect-rate-",
+  ttl_ms: CACHE_TTL_MINUTES * MS_PER_MINUTE
+};
+var defect_rate_schema = z.object({
+  days: z.number(),
+  since: z.string(),
+  defects: z.number(),
+  enhancements: z.number(),
+  is_capped: z.boolean()
+});
+async function measure_uncached(repo, days, since) {
+  const [filed, completed] = await Promise.all([
+    issue_search.search(defect_rate.filed_query(repo, since)),
+    issue_search.search(defect_rate.completed_query(repo, since))
+  ]);
+  if (filed === void 0 || completed === void 0) return void 0;
+  const is_capped = filed.is_capped || completed.is_capped;
+  return defect_rate.measure({
+    days,
+    since,
+    filed: filed.issues,
+    completed: completed.issues,
+    is_capped
+  });
+}
+async function measure_window(repo, days, now_ms) {
+  const since = defect_rate.window_start(now_ms, days);
+  const key = [repo, String(days), since].join(" ");
+  return await shared_cache.remember(
+    { slot: RATE_CACHE, key, schema: defect_rate_schema },
+    async () => await measure_uncached(repo, days, since),
+    now_ms
+  );
+}
+var defect_rate_cli = { RATE_CACHE, measure_window };
+
+// scripts/backlog/backlog-defect-priority.ts
+var UNMEASURED_MESSAGE = "The defect rate could not be read from GitHub, so defects are offered first without deferring new mechanisms.";
+var KIND_RANK = { defect: 0, other: 1, mechanism: 1 };
+var DEFERRED_KIND_RANK = { ...KIND_RANK, mechanism: 2 };
+function above_message(measured) {
+  return `The defect rate ${defect_rate.rate_text(measured)} is above its baseline ${String(defect_rate.BASELINE_RATE)}, so among issues the ranking keys tie, defects are offered first and new mechanisms last.`;
+}
+function should_defer_mechanisms(measured) {
+  if (measured === void 0) {
+    console.error(UNMEASURED_MESSAGE);
+    return false;
+  }
+  if (!defect_rate.is_above_baseline(measured)) return false;
+  console.error(above_message(measured));
+  return true;
+}
+async function kind_of_child(child) {
+  const body = child.body ?? await git_gh_command.issue_get_body(String(child.number), child.repo);
+  return defect_rate.kind_of({ body: body ?? "", labels: child.labels });
+}
+async function reorder_bundle(bundle, is_above_baseline) {
+  const kinds = await Promise.all(bundle.children.map(async (child) => await kind_of_child(child)));
+  const ranks = is_above_baseline ? DEFERRED_KIND_RANK : KIND_RANK;
+  const ranked = bundle.children.map((child, index) => ({
+    child,
+    rank: ranks[kinds[index] ?? "other"]
+  }));
+  const children = ranked.toSorted((left, right) => left.rank - right.rank).map((row) => row.child);
+  return { ...bundle, children };
+}
+async function reorder(result, repo, is_above_baseline) {
+  const candidates = await Promise.all(
+    result.candidates.map(
+      async (bundle) => bundle.repo === repo ? await reorder_bundle(bundle, is_above_baseline) : bundle
+    )
+  );
+  return { ...result, candidates };
+}
+async function prioritize(result, repo, now_ms = Date.now()) {
+  if (result.verdict !== "run") return result;
+  const days = defect_rate.DEFAULT_WINDOW_DAYS;
+  const measured = await defect_rate_cli.measure_window(repo, days, now_ms);
+  return await reorder(result, repo, should_defer_mechanisms(measured));
+}
+var backlog_defect_priority = { UNMEASURED_MESSAGE, prioritize };
+
+// scripts/backlog/backlog-pool.ts
+var EPIC_LABELS = /* @__PURE__ */ new Set([EPIC_LABEL]);
+var DECISION_LABELS = PARKED_LABELS;
+function is_epic_row(issue) {
+  return has_any_label(issue.labels, EPIC_LABELS);
+}
+function waits_outside(issue, running, repo) {
+  return epic_issue.blocker_references_of(issue, repo).some((blocker) => blocker.state === "OPEN" && !running.has(epic_graph.blocker_key(blocker)));
+}
+function is_stuck(issue, running, context) {
+  return !auto_ok_author.is_author_trusted(issue) || has_any_label(issue.labels, DECISION_LABELS) || waits_outside(issue, running, context.repo);
+}
+function needs_person(issue, context) {
+  return is_stuck(issue, context.running, context);
+}
+function epic_keys_of(tracking, repo) {
+  return new Set([...tracking.values()].flat().map((number) => epic_graph.key_of({ repo, number })));
+}
+function with_tracking_epics(running, tracking, repo) {
+  const tracking_epics = [...tracking].filter(([child]) => running.has(epic_graph.key_of({ repo, number: child }))).flatMap(([, epics]) => epics.map((number) => epic_graph.key_of({ repo, number })));
+  const grown = /* @__PURE__ */ new Set([...running, ...tracking_epics]);
+  return grown.size === running.size ? running : with_tracking_epics(grown, tracking, repo);
+}
+function rooted(running, tracking, repo) {
+  const epics = epic_keys_of(tracking, repo);
+  const members = new Set([...running].filter((key) => !epics.has(key)));
+  return with_tracking_epics(members, tracking, repo);
+}
+function settle_standalone(running, issues, context, tracking) {
+  const settled = new Set(running);
+  for (const issue of issues) {
+    if (is_stuck(issue, running, context)) {
+      settled.delete(epic_graph.key_of({ repo: context.repo, number: issue.number }));
+    }
+  }
+  const next = rooted(settled, tracking, context.repo);
+  return next.size === running.size ? next : settle_standalone(next, issues, context, tracking);
+}
+function to_child(issue, repo) {
+  return {
+    number: issue.number,
+    repo,
+    state: "OPEN",
+    labels: (issue.labels ?? []).map((label) => label.name),
+    blocked_by: epic_issue.blocker_references_of(issue, repo),
+    body: issue.body,
+    author_association: issue.author_association,
+    user: issue.user
+  };
+}
+function to_children(issues, repo) {
+  return issues.map((issue) => to_child(issue, repo));
+}
+function opted_in_epics(issues, tracking) {
+  return [...epic_index.reachable_epic_numbers(tracking, issues)];
+}
+async function read_epics(pool) {
+  const { issues } = pool.opted_in;
+  const references = opted_in_epics(issues, pool.tracking.index).map((number) => ({ number }));
+  const listed = new Map(to_children(issues, pool.repo).map((child) => [child.number, child]));
+  return await epic_next_read.read_snapshots(references, pool.repo, { repo: pool.repo, listed });
+}
+function standalone_rows(issues) {
+  return issues.filter((issue) => !is_epic_row(issue));
+}
+function is_considered(issue, context) {
+  return !context.tracked.has(issue.number) && !context.exclude.includes(issue.number);
+}
+function classify_standalone(issues, context) {
+  const considered = issues.filter((issue) => is_considered(issue, context));
+  const runnable = git_next_issues.order(
+    considered.filter((issue) => auto_ok_cli.is_runnable(issue, context.tracked, context.exclude))
+  );
+  const offered = new Set(runnable.map((issue) => issue.number));
+  const withheld = considered.filter((issue) => !offered.has(issue.number));
+  return {
+    runnable: to_children(runnable, context.repo),
+    time: to_children(
+      withheld.filter((issue) => !needs_person(issue, context)),
+      context.repo
+    ),
+    human: to_children(
+      withheld.filter((issue) => needs_person(issue, context)),
+      context.repo
+    )
+  };
+}
+function running_set(graphs, issues, context, tracking) {
+  const running = epic_outside_blocker.running_keys([
+    ...graphs.flat().filter((child) => child.state === "OPEN"),
+    ...to_children(standalone_rows(issues), context.repo)
+  ]);
+  return settle_standalone(rooted(running, tracking, context.repo), issues, context, tracking);
+}
+function cross_epic_cycles(graphs, standalone) {
+  const within = new Set(
+    [...graphs, standalone].flatMap((children) => epic_graph.find_stuck_children(children))
+  );
+  const union = [...epic_graph.index_children([...graphs.flat(), ...standalone]).values()];
+  const stuck = epic_graph.find_stuck_children(
+    union.filter((child) => !within.has(epic_graph.key_of(child)))
+  );
+  if (stuck.length === 0) return [];
+  return [
+    {
+      kind: "cycle",
+      message: `Dependency cycle across the backlog: ${stuck.join(", ")} can never start until a person breaks it`
+    }
+  ];
+}
+function unique_children(children) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const child of children) {
+    if (seen.has(epic_graph.key_of(child))) continue;
+    seen.add(epic_graph.key_of(child));
+    unique.push(child);
+  }
+  return unique;
+}
+function without(children, taken) {
+  return children.filter((child) => !taken.has(epic_graph.key_of(child)));
+}
+function keys_of(children) {
+  return new Set(children.map((child) => epic_graph.key_of(child)));
+}
+function trusted_graphs(graphs, untrusted) {
+  return graphs.map((children) => without(children, untrusted));
+}
+function waits_on(child, held) {
+  return child.blocked_by.some((blocker) => held.has(epic_graph.blocker_key(blocker)));
+}
+function with_dependants(children, held) {
+  const grown = /* @__PURE__ */ new Set([...held, ...keys_of(children.filter((child) => waits_on(child, held)))]);
+  return grown.size === held.size ? held : with_dependants(children, grown);
+}
+function epic_classification(views, untrusted) {
+  const waiting = views.flatMap((view) => view.result.waiting);
+  const offered = views.flatMap(
+    (view) => view.result.candidates.flatMap((bundle) => bundle.children)
+  );
+  const held = with_dependants(waiting, untrusted);
+  const human = unique_children([
+    ...views.flatMap((view) => view.result.blocked_on_people),
+    ...[...waiting, ...offered].filter((child) => held.has(epic_graph.key_of(child)))
+  ]);
+  const time = without(unique_children(waiting), keys_of(human));
+  return {
+    runnable: without(unique_children(offered), keys_of([...human, ...time])),
+    time,
+    human
+  };
+}
+function is_kept(child, exclude, repo) {
+  return child.repo !== repo || !exclude.includes(child.number);
+}
+function drop_excluded(classification, exclude, repo) {
+  return {
+    runnable: classification.runnable.filter((child) => is_kept(child, exclude, repo)),
+    time: classification.time.filter((child) => is_kept(child, exclude, repo)),
+    human: classification.human.filter((child) => is_kept(child, exclude, repo))
+  };
+}
+function merge_classifications(left, right) {
+  return {
+    runnable: [...left.runnable, ...right.runnable],
+    time: [...left.time, ...right.time],
+    human: [...left.human, ...right.human]
+  };
+}
+function standalone_keys(issues, context) {
+  return keys_of(
+    to_children(
+      standalone_rows(issues).filter((issue) => is_considered(issue, context)),
+      context.repo
+    )
+  );
+}
+var backlog_pool = {
+  classify_standalone,
+  cross_epic_cycles,
+  running_set,
+  settle_standalone,
+  standalone_keys,
+  drop_excluded,
+  epic_classification,
+  merge_classifications,
+  opted_in_epics,
+  read_epics,
+  standalone_rows,
+  to_child,
+  to_children,
+  trusted_graphs
+};
+
+// scripts/backlog/backlog-gate-scope.ts
+var IDLE = { kind: "idle" };
+function standalone_keys2(context) {
+  return backlog_pool.standalone_keys(context.opted_in.issues, {
+    tracked: epic_index.withheld_children(context.tracking.index, context.opted_in.issues),
+    exclude: context.exclude,
+    repo: context.repo
+  });
+}
+function yielded_keys(context, directory) {
+  const yielded = context.opted_in.issues.filter(
+    (issue) => lane_plan.is_yielded(issue.number, directory)
+  );
+  return new Set(yielded.map(({ number }) => epic_graph.key_of({ number, repo: context.repo })));
+}
+async function gate_scope(context, read2 = IDLE) {
+  const { issues } = context.opted_in;
+  const directory = process.cwd();
+  const declared = await backlog_plan_comment.declared_of(issues, directory);
+  const holders = backlog_overlap.running_numbers(read2);
+  return {
+    standalone: standalone_keys2(context),
+    declared: lane_plan.with_holder_plans(declared, holders, directory),
+    lanes: await lane_state.read_states(issues.map((issue) => String(issue.number))),
+    yielded: yielded_keys(context, directory)
+  };
+}
+var backlog_gate_scope = { gate_scope };
+
+// scripts/issue/issue-cap-files.ts
+import path from "node:path";
+var PERCENT = 100;
+var CAP_PERCENT = 90;
+var CAP_FRACTION = CAP_PERCENT / PERCENT;
+var NO_LINES_PREFIX = issue_body_keys.prefix("no_lines");
+var REFACTOR_PREFIX = issue_body_keys.prefix("refactor_first");
+var ISSUE_REFERENCE = /^#\d+$/u;
+var REFACTOR_GUIDE = "prompts/refactoring.md";
+var CODE_FILE = /\.(?:[cm]?[jt]sx?|svelte)$/u;
+function counted_paths(body, project_root) {
+  return run_prep_locate.names_of(body).filter((name) => CODE_FILE.test(name)).filter((name) => line_budget.is_lintable_path(path.resolve(project_root, name)));
+}
+function is_near_cap(budget) {
+  if (budget === void 0) return false;
+  return budget.code_lines >= Math.ceil(budget.limit * CAP_FRACTION);
+}
+function is_declared(body) {
+  if ((size_estimate.declared(body, NO_LINES_PREFIX) ?? "") !== "") return true;
+  return ISSUE_REFERENCE.test(size_estimate.declared(body, REFACTOR_PREFIX) ?? "");
+}
+function near_of(named, budgets) {
+  const near = budgets.filter((entry) => is_near_cap(entry.budget));
+  return named.map((paths) => near.filter((entry) => paths.includes(entry.file_path)));
+}
+async function near_cap_by_body(bodies, project_root) {
+  const named = bodies.map((body) => is_declared(body) ? [] : counted_paths(body, project_root));
+  const paths = [...new Set(named.flat())];
+  if (paths.length === 0) return named.map(() => []);
+  return near_of(named, await line_budget.budgets_for(paths, project_root));
+}
+async function near_cap(body, project_root) {
+  const [near] = await near_cap_by_body([body], project_root);
+  return near ?? [];
+}
+function described(entry) {
+  const { budget } = entry;
+  return budget === void 0 ? entry.file_path : `${entry.file_path} (${line_budget.describe(budget)})`;
+}
+function named_line(near) {
+  return `names ${near.map((entry) => described(entry)).join(", ")}, at or past ${String(CAP_PERCENT)}% of the code-line limit`;
+}
+function problem(near) {
+  if (near.length === 0) return void 0;
+  return `${named_line(near)} \u2014 file a refactor Issue that splits it first (${REFACTOR_GUIDE}), refile this one declaring \`${REFACTOR_PREFIX} #<refactor>\`, then \`pnpm josh backlog:triage --apply <N> --blocked-by <refactor> --reason "<why>"\`; or declare \`${NO_LINES_PREFIX} <\u7406\u7531>\` when the change adds no lines to it`;
+}
+function note(near) {
+  if (near.length === 0) return void 0;
+  return `${named_line(near)} with no \`${NO_LINES_PREFIX}\` \u2014 split it first (${REFACTOR_GUIDE})`;
+}
+var issue_cap_files = {
+  NO_LINES_PREFIX,
+  REFACTOR_PREFIX,
+  near_cap,
+  near_cap_by_body,
+  note,
+  problem
+};
+
+// scripts/backlog/backlog-next-size.ts
+function remedy_of(route) {
+  return route === SPLIT_ROUTE_LABEL ? `on a \`${SPLIT_ROUTE_LABEL}\` child \u2014 split it further` : `with no \`${split_assess.REASON_PREFIX}\``;
+}
+function limit_note(body, route, rate, growth) {
+  const capped = size_estimate.over_cap(body, route, rate, growth);
+  return capped === void 0 ? size_estimate.budget_note(body, rate, growth) : size_estimate.capped(capped, rate, growth);
+}
+function guide_note(body, route, rate, growth) {
+  const guide = size_estimate.over_guide(body, route, rate, growth) ?? size_estimate.split_over_guide(body, route, rate, growth);
+  return guide === void 0 ? void 0 : `${size_estimate.exceeded(guide, rate, growth)} ${remedy_of(route)}`;
+}
+function size_note(row, context) {
+  const route = size_estimate.route_of(row.labels);
+  const body = row.body ?? "";
+  const { implement_rate, growth } = context;
+  return limit_note(body, route, implement_rate, growth) ?? guide_note(body, route, implement_rate, growth);
+}
+function note_of(row, context) {
+  const note2 = size_note(row, context);
+  if (note2 === void 0) return void 0;
+  const cited2 = session_cite.issue(row.number, void 0, row.repo);
+  return `${cited2} ${note2} \u2014 split-assessment.md \u2192 "${split_assess.QUESTION_SECTION}"`;
+}
+function cap_note_of(row, near = []) {
+  const note2 = issue_cap_files.note(near);
+  return note2 === void 0 ? void 0 : `${session_cite.issue(row.number, void 0, row.repo)} ${note2}`;
+}
+async function warn_over_guide(offered, context) {
+  const bodies = offered.map((row) => row.body ?? "");
+  const near = await issue_cap_files.near_cap_by_body(bodies, process.cwd());
+  const notes = offered.flatMap((row, index) => [
+    note_of(row, context),
+    cap_note_of(row, near[index])
+  ]);
+  for (const note2 of notes) if (note2 !== void 0) console.error(note2);
+}
+var backlog_next_size = { warn_over_guide };
+
+// scripts/backlog/backlog-wait-cause.ts
+var CAUSES = ["chain", "gate", "lane"];
+var MARKS = {
+  chain: "Waiting on a dependency chain:",
+  gate: "Waiting on a start condition:",
+  lane: "Waiting on a running lane:"
+};
+var TAG_SEPARATOR = "+";
+var ISSUE_PATTERN = /#(\d+)/gu;
+var DEADLINE_MARK = "Next start time: ";
+var RESOLVED_VERDICT = "resolved";
+function has_pending_blocker(child) {
+  return child.blocked_by.some(
+    (blocker) => epic_cross_repo.resolve_cross_repo(
+      { ...blocker, state: blocker.state ?? "OPEN", labels: [], blocked_by: [] },
+      child
+    ) !== RESOLVED_VERDICT
+  );
+}
+function cause_of(child) {
+  if (has_label_name(child.labels, IN_PROGRESS_LABEL)) return void 0;
+  if (!issue_not_before.is_due(child.body)) return "gate";
+  return has_pending_blocker(child) ? "chain" : "lane";
+}
+function deadline_of(children) {
+  const dates = children.filter((child) => cause_of(child) === "gate").map((child) => issue_not_before.waiting_ms(child.body)).filter((date) => date !== void 0);
+  return dates.length === 0 ? {} : { not_before_ms: Math.min(...dates) };
+}
+function numbers_with(children, cause) {
+  return children.filter((child) => cause_of(child) === cause).map((child) => child.number);
+}
+function classify(children, repo) {
+  const here2 = children.filter((child) => child.repo === repo);
+  return {
+    chain: numbers_with(here2, "chain"),
+    gate: numbers_with(here2, "gate"),
+    lane: numbers_with(here2, "lane"),
+    ...deadline_of(here2)
+  };
+}
+function cited(numbers) {
+  return numbers.map((number) => issue_cite.plain_for("program", number)).join(" ");
+}
+function lines_of(causes) {
+  const lines = CAUSES.filter((cause) => causes[cause].length > 0).map(
+    (cause) => `${MARKS[cause]} ${cited(causes[cause])}`
+  );
+  return causes.not_before_ms === void 0 ? lines : [...lines, `${DEADLINE_MARK}${String(causes.not_before_ms)}`];
+}
+function numbers_on(text, cause) {
+  const line = text.split("\n").find((candidate) => candidate.startsWith(MARKS[cause]));
+  return [...(line ?? "").matchAll(ISSUE_PATTERN)].map((match) => Number(match[1]));
+}
+function parse(text) {
+  const deadline = text.split("\n").find((line) => line.startsWith(DEADLINE_MARK));
+  const not_before_ms = Number(deadline?.slice(DEADLINE_MARK.length));
+  return {
+    chain: numbers_on(text, "chain"),
+    gate: numbers_on(text, "gate"),
+    lane: numbers_on(text, "lane"),
+    ...Number.isFinite(not_before_ms) && { not_before_ms }
+  };
+}
+function tag_of(causes) {
+  const present = CAUSES.filter((cause) => causes[cause].length > 0);
+  return present.length > 0 ? present.join(TAG_SEPARATOR) : void 0;
+}
+function causes_of_tag(tag) {
+  const parts = tag.split(TAG_SEPARATOR);
+  const causes = CAUSES.filter((cause) => parts.includes(cause));
+  return causes.length === parts.length ? causes : void 0;
+}
+function numbers_of(causes) {
+  return CAUSES.flatMap((cause) => causes[cause]);
+}
+var backlog_wait_cause = {
+  cause_of,
+  causes_of_tag,
+  classify,
+  lines_of,
+  numbers_of,
+  parse,
+  tag_of
+};
+
+// scripts/backlog/backlog-next-report.ts
+var SUCCESS_EXIT_CODE = 0;
+var RETRY_MESSAGE = "GitHub did not answer, so a child of the dependency graph could not be read. This is a transport failure and not an unusable graph \u2014 the listings this command already read prove `gh` and the credentials work. Ask again after a short wait.";
+var VERDICT_TOKENS = {
+  complete: auto_ok_cli.NONE_TOKEN,
+  error: "error",
+  retry: "retry",
+  run: "run",
+  stop: "stop",
+  triage: epic_triage.TRIAGE_VERDICT,
+  wait: "wait"
+};
+function tokens_of(result, repo) {
+  if (result.verdict !== "run") return [VERDICT_TOKENS[result.verdict]];
+  const here2 = epic_report.candidates_for_repo(result, repo);
+  if (here2.length === 0) return [VERDICT_TOKENS.wait];
+  return here2.map((child) => String(child.number));
+}
+function offered_of(result, repo) {
+  return result.verdict === "run" ? epic_report.candidates_for_repo(result, repo) : [];
+}
+function warn_epic_gap(context) {
+  const epics = epic_bundle_gaps.epic_gap(context.tracking.cutoff, auto_ok_cli.LISTING_LIMIT);
+  if (epics !== void 0) console.error(epics);
+}
+function warn_gaps(context, has_answer) {
+  const listing = auto_ok_cli.truncation_note(context.opted_in.cutoff, has_answer);
+  if (listing !== void 0) console.error(listing);
+  warn_epic_gap(context);
+}
+function warn_not_before(context) {
+  for (const issue of context.opted_in.issues) {
+    const reason = issue_not_before.waiting_reason(issue.body);
+    if (reason === void 0) continue;
+    const cited2 = session_cite.issue(issue.number, void 0, context.repo);
+    console.error(`${cited2} ${issue_citation.linkify(reason, context.repo)}`);
+  }
+}
+function warn_wait_causes(result, context) {
+  const causes = backlog_wait_cause.classify(result.waiting, context.repo);
+  for (const line of backlog_wait_cause.lines_of(causes)) {
+    console.error(issue_citation.linkify(line, context.repo));
+  }
+}
+async function report(result, context) {
+  warn_gaps(context, result.verdict === "run");
+  const explanation = epic_report.format_result(result, context.repo);
+  console.error(issue_citation.linkify(explanation, context.repo));
+  warn_not_before(context);
+  const tokens = tokens_of(result, context.repo);
+  if (tokens[0] === VERDICT_TOKENS.wait) warn_wait_causes(result, context);
+  await backlog_next_size.warn_over_guide(offered_of(result, context.repo), context);
+  for (const token of tokens) console.info(token);
+  return SUCCESS_EXIT_CODE;
+}
+function report_retry(context) {
+  warn_epic_gap(context);
+  console.error(RETRY_MESSAGE);
+  console.info(VERDICT_TOKENS.retry);
+  return SUCCESS_EXIT_CODE;
+}
+function report_triage(context, untriaged) {
+  warn_epic_gap(context);
+  console.error(epic_triage.message(untriaged, context.repo));
+  console.info(VERDICT_TOKENS.triage);
+  return SUCCESS_EXIT_CODE;
+}
+function without_untriaged(result, repo) {
+  const candidates = result.candidates.map(
+    (bucket) => bucket.repo === repo ? { ...bucket, children: bucket.children.filter((child) => epic_triage.is_triaged(child)) } : bucket
+  );
+  return { ...result, candidates };
+}
+function has_offer(result, repo) {
+  return result.verdict === "run" && epic_report.candidates_for_repo(result, repo).length > 0;
+}
+async function report_held(gated, context, untriaged) {
+  if (!has_offer(gated, context.repo)) return report_triage(context, untriaged);
+  await report(gated, context);
+  console.error(epic_triage.held_message(untriaged, context.repo));
+  console.info(VERDICT_TOKENS.triage);
+  return SUCCESS_EXIT_CODE;
+}
+function report_none() {
+  console.error(auto_ok_cli.NONE_OPTED_IN_MESSAGE);
+  console.info(auto_ok_cli.NONE_TOKEN);
+  return SUCCESS_EXIT_CODE;
+}
+var backlog_next_report = {
+  RETRY_MESSAGE,
+  VERDICT_TOKENS,
+  offered_of,
+  report,
+  report_retry,
+  tokens_of,
+  without_untriaged,
+  report_held,
+  report_none
+};
+
+// scripts/backlog/backlog-next-offer.ts
+var { VERDICT_TOKENS: VERDICT_TOKENS2 } = backlog_next_report;
+var EXCLUDE_REASON = "exclude";
+var TRIAGE_REASON = "triage";
+var PERSON_REASON = "person";
+var WAIT_REASON = "wait";
+var SOLO_REASON = "solo";
+function base_of(opted_in, verdict) {
+  return {
+    verdict,
+    seen: opted_in.issues.map((issue) => issue.number),
+    started: [],
+    excluded: [],
+    is_unchanged: opted_in.is_unchanged === true
+  };
+}
+function excluded_by_request(context) {
+  return context.exclude.map((issue) => ({ issue, reason: EXCLUDE_REASON }));
+}
+function here(children, repo) {
+  return children.filter((child) => child.repo === repo);
+}
+function numbers_of2(children) {
+  return new Set(children.map((child) => child.number));
+}
+function withheld_of(outcome, repo) {
+  const after = numbers_of2(backlog_next_report.offered_of(outcome.gated, repo));
+  return numbers_of2(
+    backlog_next_report.offered_of(outcome.pre_gate, repo).filter((child) => !after.has(child.number))
+  );
+}
+function waiting_reason(child, withheld) {
+  if (withheld.has(child.number)) return SOLO_REASON;
+  return backlog_wait_cause.cause_of(child) ?? WAIT_REASON;
+}
+function excluded_of(context, outcome, untriaged) {
+  const { repo } = context;
+  const result = outcome.gated;
+  const withheld = withheld_of(outcome, repo);
+  return [
+    ...excluded_by_request(context),
+    ...untriaged.map((child) => ({ issue: child.number, reason: TRIAGE_REASON })),
+    ...here(result.waiting, repo).map((child) => ({
+      issue: child.number,
+      reason: waiting_reason(child, withheld)
+    })),
+    ...here(result.blocked_on_people, repo).map((child) => ({
+      issue: child.number,
+      reason: PERSON_REASON
+    }))
+  ];
+}
+function verdict_of(result, repo, untriaged, started) {
+  if (started.length > 0) return VERDICT_TOKENS2.run;
+  if (untriaged.length > 0) return VERDICT_TOKENS2.triage;
+  return backlog_next_report.tokens_of(result, repo).join(",");
+}
+async function record_answer(context, outcome, untriaged) {
+  const { gated } = outcome;
+  const started = backlog_next_report.offered_of(gated, context.repo).map((child) => child.number);
+  await lane_ledger_write.record_offer({
+    ...base_of(context.opted_in, verdict_of(gated, context.repo, untriaged, started)),
+    started,
+    excluded: excluded_of(context, outcome, untriaged)
+  });
+}
+async function record_retry(context) {
+  await lane_ledger_write.record_offer({
+    ...base_of(context.opted_in, VERDICT_TOKENS2.retry),
+    excluded: excluded_by_request(context)
+  });
+}
+async function record_none(opted_in) {
+  await lane_ledger_write.record_offer(base_of(opted_in, VERDICT_TOKENS2.complete));
+}
+var backlog_next_offer = { record_answer, record_none, record_retry };
+
+// scripts/backlog/backlog-rank.ts
+function everything_in(result) {
+  const candidates = result.candidates.flatMap((bundle) => bundle.children);
+  return [...candidates, ...result.waiting, ...result.blocked_on_people];
+}
+var { rank } = epic_rank;
+function reorder_repo(result, repo, order) {
+  if (result.verdict !== "run") return result;
+  return {
+    ...result,
+    candidates: result.candidates.map(
+      (bundle) => bundle.repo === repo ? { ...bundle, children: order(bundle.children) } : bundle
+    )
+  };
+}
+function rank_result(result, repo) {
+  const pool = everything_in(result);
+  return reorder_repo(result, repo, (children) => rank(children, pool));
+}
+function overflow_of(offered, standalone, limit) {
+  const keys = offered.map((child) => epic_graph.key_of(child)).filter((key) => standalone.has(key));
+  return new Set(keys.slice(limit));
+}
+function is_in(child, keys) {
+  return keys.has(epic_graph.key_of(child));
+}
+function cap(selection, standalone, limit) {
+  const overflow = overflow_of(selection.offered, standalone, limit);
+  if (overflow.size === 0) return selection;
+  return {
+    ...selection,
+    offered: selection.offered.filter((child) => !is_in(child, overflow)),
+    withheld: [
+      ...selection.offered.filter((child) => is_in(child, overflow)),
+      ...selection.withheld
+    ]
+  };
+}
+function yielded_first(ranked, yielded) {
+  return [
+    ...ranked.filter((child) => is_in(child, yielded)),
+    ...ranked.filter((child) => !is_in(child, yielded))
+  ];
+}
+function offer_order(result, repo, yielded = /* @__PURE__ */ new Set()) {
+  return reorder_repo(result, repo, (children) => yielded_first(children, yielded));
+}
+function select(input) {
+  const ranked = yielded_first(rank(input.candidates, input.pool), input.yielded ?? /* @__PURE__ */ new Set());
+  const { read: read2, repo, lanes } = input;
+  const gated = epic_solo.select(ranked, read2, repo);
+  const separated = backlog_overlap.separate(gated, input.declared ?? /* @__PURE__ */ new Map(), {
+    read: read2,
+    repo,
+    lanes
+  });
+  return cap(separated, input.standalone, input.limit ?? git_next_issues.DISPLAY_LIMIT);
+}
+function gate(result, read2, repo, scope) {
+  const pool = everything_in(result);
+  return epic_solo.gate(
+    result,
+    read2,
+    repo,
+    (candidates) => select({ candidates, pool, read: read2, repo, ...scope })
+  );
+}
+var backlog_rank = { everything_in, gate, offer_order, rank_result, select };
+
+// scripts/run/pause/run-pause-comment.ts
+import { z as z2 } from "zod";
+var comment_schema = z2.object({ body: z2.string().nullish() });
+async function has_comment(request) {
+  const json = await git_gh_issue_read.issue_list_comments(request.issue);
+  const rows = json === void 0 ? void 0 : parse_json_array_or_undefined(json, comment_schema);
+  if (rows === void 0) {
+    throw new Error(`the comments on ${session_cite.issue(request.issue)} could not be read`);
+  }
+  return rows.some((row) => row.body?.includes(request.marker) === true);
+}
+function marker_of(issue) {
+  return `<!-- josh:run-pause ${issue_cite.plain_for("program", issue)} for `;
+}
+async function is_paused(issue) {
+  return await has_comment({ issue, marker: marker_of(issue) });
+}
+var run_pause_comment = { has_comment, marker_of, is_paused };
+
+// scripts/backlog/backlog-resume-reads.ts
+import { z as z3 } from "zod";
+var COMMENTS_WINDOW = 100;
+var LINE_SEPARATOR = "\n";
+var OPEN_PULLS_QUERY = "/pulls?state=open&per_page=100";
+var PULL_FILTER = '.[] | {body: (.body // "")}';
+var ALIAS_PREFIX = "i";
+var pull_schema = z3.object({ body: z3.string() });
+var comment_schema2 = z3.looseObject({ body: z3.string().nullish() });
+var page_info_schema = z3.looseObject({ hasPreviousPage: z3.boolean() });
+var comments_schema = z3.looseObject({
+  pageInfo: page_info_schema,
+  nodes: z3.array(comment_schema2)
+});
+var issue_node_schema = z3.looseObject({ comments: comments_schema }).nullable();
+var repository_schema = z3.record(z3.string(), issue_node_schema);
+var response_schema = z3.looseObject({ data: z3.looseObject({ repository: repository_schema }) });
+function referenced_issues_of(line, repo) {
+  const pull = parse_json_object_or_undefined(line, pull_schema);
+  if (pull === void 0) {
+    throw new Error("the open pull request listing contains an unreadable row");
+  }
+  return epic_audit_logic.parse_references(pull.body, repo).map(String);
+}
+async function open_pr_issues(repo) {
+  const raw = await git_gh_exec.exec_gh_api({
+    path: `${git_gh_api_path.repo_api_path(repo)}${OPEN_PULLS_QUERY}`,
+    should_paginate: true,
+    jq_filter: PULL_FILTER
+  });
+  return new Set(
+    raw.split(LINE_SEPARATOR).filter((line) => line.trim() !== "").flatMap((line) => referenced_issues_of(line, repo))
+  );
+}
+function alias_of(issue) {
+  return `${ALIAS_PREFIX}${issue}`;
+}
+function comments_query(issues) {
+  const fields = issues.map(
+    (issue) => `${alias_of(issue)}: issue(number: ${issue}) { comments(last: ${String(COMMENTS_WINDOW)}) { pageInfo { hasPreviousPage } nodes { body } } }`
+  );
+  return `query($owner: String!, $name: String!) { repository(owner: $owner, name: $name) { ${fields.join(" ")} } }`;
+}
+async function read_windows(issues, repo) {
+  const separator = repo.indexOf("/");
+  const owner = repo.slice(0, separator);
+  const name = repo.slice(separator + 1);
+  try {
+    const json = await git_gh_exec.exec_gh_api({
+      path: GRAPHQL_PATH,
+      body: JSON.stringify({ query: comments_query(issues), variables: { owner, name } })
+    });
+    return parse_json_object_or_undefined(json, response_schema)?.data.repository ?? {};
+  } catch {
+    return {};
+  }
+}
+function window_verdict(issue, node) {
+  if (node === void 0 || node === null) return void 0;
+  const marker = run_pause_comment.marker_of(issue);
+  if (node.comments.nodes.some((comment) => comment.body?.includes(marker) === true)) return true;
+  return node.comments.pageInfo.hasPreviousPage ? void 0 : false;
+}
+async function paused_issues(issues, repo) {
+  if (issues.length === 0) return /* @__PURE__ */ new Set();
+  const windows = await read_windows(issues, repo);
+  const verdicts = await Promise.all(
+    issues.map(
+      async (issue) => window_verdict(issue, windows[alias_of(issue)]) ?? await run_pause_comment.is_paused(issue)
+    )
+  );
+  return new Set(issues.filter((_issue, index) => verdicts[index] === true));
+}
+var backlog_resume_reads = { open_pr_issues, paused_issues };
+
+// scripts/backlog/backlog-resumable.ts
+var NO_ISSUES = /* @__PURE__ */ new Set();
+function is_resumable(issue, signals) {
+  return signals.stashed.has(issue) || signals.paused.has(issue) || signals.open_pr.has(issue);
+}
+function enrich_children(children, repo, signals) {
+  return children.map(
+    (child) => child.repo === repo ? { ...child, is_resumable: is_resumable(String(child.number), signals) } : child
+  );
+}
+function local_issues(result, repo) {
+  const children = [...result.candidates.flatMap((bundle) => bundle.children), ...result.waiting];
+  const local = children.filter((child) => child.repo === repo);
+  return [...new Set(local.map((child) => String(child.number)))];
+}
+async function read_signals(result, repo) {
+  const stashed = new Set(stash_orphans.issues_of(await git_stash.list()));
+  const unstashed = local_issues(result, repo).filter((issue) => !stashed.has(issue));
+  if (unstashed.length === 0) return { stashed, paused: NO_ISSUES, open_pr: NO_ISSUES };
+  const [paused, open_pr] = await Promise.all([
+    backlog_resume_reads.paused_issues(unstashed, repo),
+    backlog_resume_reads.open_pr_issues(repo)
+  ]);
+  return { stashed, paused, open_pr };
+}
+async function read(result, repo) {
+  if (result.verdict !== "run") return result;
+  const signals = await read_signals(result, repo);
+  const candidates = result.candidates.map((bundle) => ({
+    ...bundle,
+    children: enrich_children(bundle.children, repo, signals)
+  }));
+  return { ...result, candidates, waiting: enrich_children(result.waiting, repo, signals) };
+}
+var backlog_resumable = { read };
+
+// scripts/backlog/backlog-next.ts
+var FAILURE_EXIT_CODE = 1;
+var USAGE = "Usage: josh backlog:next [--exclude <issue-number>[,<issue-number>...]]...";
+var REPO_UNREADABLE_MESSAGE = 'Could not read this repository from `gh`, so an epic child could not be told from an issue elsewhere. That is not "nothing is runnable" \u2014 check `gh auth status` and ask again.';
+var READ_FAILURES = {
+  blockers_unreadable: auto_ok_cli.BLOCKERS_UNREADABLE_MESSAGE,
+  unexpected_shape: auto_ok_cli.UNEXPECTED_SHAPE_MESSAGE,
+  unreadable: auto_ok_cli.UNREADABLE_MESSAGE
+};
+function running_of(views, graphs, context) {
+  return views[0]?.running ?? backlog_pool.running_set(graphs, context.opted_in.issues, context, context.tracking.index);
+}
+function epic_half(views, context, untrusted) {
+  return backlog_pool.drop_excluded(
+    backlog_pool.epic_classification(views, untrusted),
+    context.exclude,
+    context.repo
+  );
+}
+function combine(views, context, untrusted) {
+  const graphs = views.map((view) => view.snapshot.children);
+  const standalone = backlog_pool.standalone_rows(context.opted_in.issues);
+  const from_epics = epic_half(views, context, untrusted);
+  const from_standalone = backlog_pool.classify_standalone(standalone, {
+    ...context,
+    tracked: epic_index.withheld_children(context.tracking.index, context.opted_in.issues),
+    running: running_of(views, graphs, context)
+  });
+  return epic_report.build_result(
+    backlog_pool.merge_classifications(from_epics, from_standalone),
+    [
+      ...views.flatMap((view) => view.result.anomalies),
+      ...backlog_pool.cross_epic_cycles(graphs, backlog_pool.to_children(standalone, context.repo))
+    ],
+    repo_discovery.discover_repositories(PROJECT_ROOT)
+  );
+}
+function settled_views(reads, running, context) {
+  const views = epic_next.views_of(reads, running);
+  const settled = backlog_pool.settle_standalone(
+    views[0]?.running ?? running,
+    context.opted_in.issues,
+    context,
+    context.tracking.index
+  );
+  return settled.size === running.size ? views : settled_views(reads, settled, context);
+}
+function views_from(reads, context, untrusted) {
+  if (reads.length === 0) return [];
+  const graphs = backlog_pool.trusted_graphs(
+    reads.map((read2) => read2.snapshot.children),
+    untrusted
+  );
+  return settled_views(
+    reads,
+    backlog_pool.running_set(graphs, context.opted_in.issues, context, context.tracking.index),
+    context
+  );
+}
+async function resolve(context) {
+  const { reads, notices, refusal } = await backlog_pool.read_epics(context);
+  for (const notice of notices) console.error(notice);
+  if (refusal !== void 0) {
+    console.error(refusal);
+    return void 0;
+  }
+  const children = reads.flatMap((read2) => read2.snapshot.children);
+  const untrusted = await auto_ok_author.untrusted_child_keys(children, context.repo);
+  const ordered = await backlog_defect_priority.prioritize(
+    combine(views_from(reads, context, untrusted), context, untrusted),
+    context.repo
+  );
+  return backlog_rank.rank_result(await backlog_resumable.read(ordered, context.repo), context.repo);
+}
+function is_transport_failure(result) {
+  if (result.verdict !== "error") return false;
+  return result.anomalies.some((anomaly) => anomaly.is_unreachable === true);
+}
+async function gate_solo(result, context) {
+  if (result.verdict !== "run") return result;
+  const { repo } = context;
+  const { read: read2, notice } = await epic_solo_stale.release(
+    await epic_busy.read_repository(repo),
+    repo
+  );
+  if (notice !== void 0) console.error(notice);
+  const scope = await backlog_gate_scope.gate_scope(context, read2);
+  const gated = backlog_rank.gate(result, read2, repo, scope);
+  if (gated.notice !== void 0) console.error(gated.notice);
+  return gated.result;
+}
+async function answer_held(result, context, untriaged) {
+  const pre_gate = backlog_next_report.without_untriaged(result, context.repo);
+  const gated = await gate_solo(pre_gate, context);
+  await backlog_next_offer.record_answer(context, { pre_gate, gated }, untriaged);
+  return await backlog_next_report.report_held(gated, context, untriaged);
+}
+async function answer_pool(context) {
+  const resolved = await resolve(context);
+  if (resolved === void 0) return FAILURE_EXIT_CODE;
+  if (is_transport_failure(resolved)) {
+    await backlog_next_offer.record_retry(context);
+    return backlog_next_report.report_retry(context);
+  }
+  const { result, untriaged } = await backlog_auto_triage.untriaged_of(resolved, context.repo);
+  if (untriaged.length > 0) return await answer_held(result, context, untriaged);
+  const gated = await gate_solo(result, context);
+  await backlog_next_offer.record_answer(context, { pre_gate: result, gated }, []);
+  return await backlog_next_report.report(gated, context);
+}
+async function context_of(opted_in, exclude) {
+  const tracking = await auto_ok_cli.fetch_tracking(opted_in.issues.length);
+  if (tracking.kind !== "read") {
+    console.error(auto_ok_cli.EPICS_UNREADABLE_MESSAGE);
+    return void 0;
+  }
+  const repo = await git_gh_command.repo_get_name_with_owner();
+  if (repo === void 0) {
+    console.error(REPO_UNREADABLE_MESSAGE);
+    return void 0;
+  }
+  return { opted_in, tracking, repo, exclude, ...await lane_net_read.measurements() };
+}
+async function answer(opted_in, exclude) {
+  await issue_not_before_label.sweep(opted_in.issues);
+  if (opted_in.issues.length === 0) {
+    await backlog_next_offer.record_none(opted_in);
+    return backlog_next_report.report_none();
+  }
+  const context = await context_of(opted_in, exclude);
+  if (context === void 0) return FAILURE_EXIT_CODE;
+  return await answer_pool(context);
+}
+async function run(argv) {
+  const options = auto_ok_cli.parse_options(argv, USAGE);
+  if (options.usage !== void 0) {
+    console.error(options.usage);
+    return FAILURE_EXIT_CODE;
+  }
+  const opted_in = await auto_ok_cli.fetch_opted_in();
+  if (opted_in.kind !== "read") {
+    console.error(READ_FAILURES[opted_in.kind]);
+    return FAILURE_EXIT_CODE;
+  }
+  return await answer(opted_in, options.exclude ?? []);
+}
+var backlog_next = {
+  USAGE,
+  REPO_UNREADABLE_MESSAGE,
+  RETRY_MESSAGE: backlog_next_report.RETRY_MESSAGE,
+  READ_FAILURES,
+  VERDICT_TOKENS: backlog_next_report.VERDICT_TOKENS,
+  resolve,
+  context_of,
+  run
+};
+
+export {
+  issue_not_before_label,
+  backlog_auto_triage,
+  backlog_gate_scope,
+  issue_cap_files,
+  backlog_wait_cause,
+  backlog_rank,
+  run_pause_comment,
+  backlog_next
+};