@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-KCFOP5RI.js

@@ -1,1310 +0,0 @@
-import {
-  stash_orphans
-} from "./chunk-EYMPBHDN.js";
-import {
-  lane_net_read
-} from "./chunk-MFBNNTBM.js";
-import {
-  epic_next,
-  epic_next_read,
-  epic_outside_blocker,
-  epic_rank,
-  epic_report,
-  epic_solo,
-  epic_solo_stale
-} from "./chunk-TYNH2R66.js";
-import {
-  epic_triage
-} from "./chunk-VQRT32JB.js";
-import {
-  epic_cross_repo
-} from "./chunk-OX3VQLV2.js";
-import {
-  backlog_plan_comment
-} from "./chunk-AVVMDVGO.js";
-import {
-  auto_ok_author,
-  auto_ok_cli,
-  epic_bundle_gaps
-} from "./chunk-FMZWRDKH.js";
-import {
-  epic_index
-} from "./chunk-7MJYLUF4.js";
-import {
-  issue_not_before
-} from "./chunk-FKZ5E4JD.js";
-import {
-  run_prep_locate
-} from "./chunk-A4HOQKOG.js";
-import {
-  defect_rate,
-  issue_search
-} from "./chunk-SSL6A3Y4.js";
-import {
-  issue_sample_prime
-} from "./chunk-QDFVVRQP.js";
-import {
-  epic_issue
-} from "./chunk-IAD4WLLI.js";
-import {
-  git_next_issues
-} from "./chunk-HH3CVIFU.js";
-import {
-  size_estimate
-} from "./chunk-FDS65XOJ.js";
-import {
-  split_assess
-} from "./chunk-D7JRJI44.js";
-import {
-  epic_audit_logic
-} from "./chunk-ILIITIMQ.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  epic_busy
-} from "./chunk-QABRNGQV.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  backlog_overlap,
-  lane_plan
-} from "./chunk-B7ZNIEDV.js";
-import {
-  git_stash
-} from "./chunk-K64EIHD2.js";
-import {
-  issue_body_keys
-} from "./chunk-KXK2A2HB.js";
-import {
-  git_gh_issue_write
-} from "./chunk-RN2YDNLF.js";
-import {
-  git_gh_issue_read
-} from "./chunk-ENKFCOVY.js";
-import {
-  GRAPHQL_PATH
-} from "./chunk-TVZXG4Y4.js";
-import {
-  shared_cache
-} from "./chunk-C6QSVO5K.js";
-import {
-  lane_state
-} from "./chunk-ZZXO6TFH.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-22DVQCP6.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-KKIMVXAP.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
-};