@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-YNCF66RK.js

@@ -1,1052 +0,0 @@
-import {
-  backlog_next_report,
-  backlog_wait_cause
-} from "./chunk-N2ZF6T4E.js";
-import {
-  stash_orphans
-} from "./chunk-WR5PKCQW.js";
-import {
-  lane_net_read
-} from "./chunk-GBMZXFFC.js";
-import {
-  epic_next,
-  epic_next_read,
-  epic_outside_blocker,
-  epic_rank,
-  epic_solo,
-  epic_solo_stale
-} from "./chunk-AUTD5FV2.js";
-import {
-  epic_report
-} from "./chunk-4HOTJAO6.js";
-import {
-  epic_triage
-} from "./chunk-VQRT32JB.js";
-import {
-  backlog_plan_comment
-} from "./chunk-MRW2WYJS.js";
-import {
-  auto_ok_author,
-  auto_ok_cli
-} from "./chunk-RFIOZTXY.js";
-import {
-  epic_index
-} from "./chunk-NHTEC5U4.js";
-import {
-  defect_rate,
-  issue_search
-} from "./chunk-DUA4E4ES.js";
-import {
-  issue_not_before
-} from "./chunk-PCZROH3R.js";
-import {
-  issue_sample_prime
-} from "./chunk-WWLCQREY.js";
-import {
-  epic_issue
-} from "./chunk-YEAE46TS.js";
-import {
-  git_next_issues
-} from "./chunk-SRTEE34O.js";
-import {
-  epic_audit_logic
-} from "./chunk-ILIITIMQ.js";
-import {
-  epic_graph
-} from "./chunk-3RIQ36LH.js";
-import {
-  epic_busy
-} from "./chunk-6LDEZFYR.js";
-import {
-  git_gh_command
-} from "./chunk-NRULNBYI.js";
-import {
-  backlog_overlap,
-  lane_plan
-} from "./chunk-MDGPJOLK.js";
-import {
-  git_stash
-} from "./chunk-WROJTXWZ.js";
-import {
-  git_gh_issue_write
-} from "./chunk-4F4KARQN.js";
-import {
-  git_gh_issue_read
-} from "./chunk-TFYYXETQ.js";
-import {
-  GRAPHQL_PATH
-} from "./chunk-LX2ENXHZ.js";
-import {
-  shared_cache
-} from "./chunk-WXLW7S4M.js";
-import {
-  lane_state
-} from "./chunk-7EAYFMDN.js";
-import {
-  epic_issue_schema
-} from "./chunk-34DND4BA.js";
-import {
-  BUG_LABEL,
-  EPIC_LABEL,
-  NOT_BEFORE_LABEL,
-  PARKED_LABELS,
-  REPOSITORY_LABELS,
-  RUN_LANE_LABEL,
-  has_any_label,
-  has_label_name
-} from "./chunk-QQBMVC5W.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  repo_discovery
-} from "./chunk-MDKDJF2K.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  git_gh_exec,
-  parse_json,
-  parse_json_array_or_undefined,
-  parse_json_object_or_undefined
-} from "./chunk-43DU7DYZ.js";
-import {
-  run_startup
-} from "./chunk-RV7EQIE4.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  lane_ledger_write
-} from "./chunk-KIS7JFNP.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 cited = session_cite.issue(issue.number);
-    console.warn(
-      `${cited}: 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((path) => body.includes(path));
-}
-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 as z2 } from "zod";
-
-// scripts/issue/issue-search-count.ts
-import { z } from "zod";
-var count_schema = z.object({
-  total_count: z.number().int().nonnegative(),
-  incomplete_results: z.literal(false)
-});
-async function count(query) {
-  const parameters = new URLSearchParams({ q: query, per_page: "1" });
-  try {
-    const raw = await git_gh_exec.exec_gh_api({ path: `search/issues?${parameters.toString()}` });
-    return parse_json.parse_json_object_or_undefined(raw, count_schema)?.total_count;
-  } catch {
-    return void 0;
-  }
-}
-var issue_search_count = { count };
-
-// scripts/issue/defect-rate-cli.ts
-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 = z2.object({
-  days: z2.number(),
-  since: z2.string(),
-  defects: z2.number(),
-  enhancements: z2.number(),
-  is_capped: z2.boolean()
-});
-async function measure_uncached(repo, days, since, now_ms) {
-  const [filed, completed] = await Promise.all([
-    issue_search.search_complete(defect_rate.filed_query(repo, since), now_ms),
-    issue_search_count.count(defect_rate.completed_query(repo, since))
-  ]);
-  if (filed === void 0 || completed === void 0) return void 0;
-  return {
-    days,
-    since,
-    defects: filed.issues.filter((issue) => defect_rate.is_defect(issue)).length,
-    enhancements: completed,
-    is_capped: filed.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 run_startup.phase(
-    "defect rate",
-    async () => await shared_cache.remember(
-      { slot: RATE_CACHE, key, schema: defect_rate_schema },
-      async () => await measure_uncached(repo, days, since, now_ms),
-      now_ms
-    ),
-    { edge_of: (value) => value === void 0 ? "failed" : "done" }
-  );
-}
-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 || measured.is_capped) {
-    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/backlog/backlog-next-offer.ts
-var { VERDICT_TOKENS } = 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_of(children) {
-  return new Set(children.map((child) => child.number));
-}
-function withheld_of(outcome, repo) {
-  const after = numbers_of(backlog_next_report.offered_of(outcome.gated, repo));
-  return numbers_of(
-    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_TOKENS.run;
-  if (untriaged.length > 0) return VERDICT_TOKENS.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_TOKENS.retry),
-    excluded: excluded_by_request(context)
-  });
-}
-async function record_none(opted_in) {
-  await lane_ledger_write.record_offer(base_of(opted_in, VERDICT_TOKENS.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 z3 } from "zod";
-var comment_schema = z3.object({ body: z3.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 z4 } 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 = z4.object({ body: z4.string() });
-var comment_schema2 = z4.looseObject({ body: z4.string().nullish() });
-var page_info_schema = z4.looseObject({ hasPreviousPage: z4.boolean() });
-var comments_schema = z4.looseObject({
-  pageInfo: page_info_schema,
-  nodes: z4.array(comment_schema2)
-});
-var issue_node_schema = z4.looseObject({ comments: comments_schema }).nullable();
-var repository_schema = z4.record(z4.string(), issue_node_schema);
-var response_schema = z4.looseObject({ data: z4.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_ready(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;
-}
-function result_edge(value) {
-  if (value === void 0 || value.verdict === "error") return "failed";
-  return value.verdict === "wait" || value.verdict === "stop" ? "waiting" : "done";
-}
-async function gate_solo(result, context) {
-  return await run_startup.phase("eligibility", async () => await gate_ready(result, context), {
-    edge_of: result_edge
-  });
-}
-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 run_startup.phase(
-    "candidate eligibility",
-    async () => await resolve(context),
-    {
-      edge_of: result_edge
-    }
-  );
-  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 run_startup.phase("candidate listing", auto_ok_cli.fetch_opted_in, {
-    edge_of: (value) => value.kind === "read" ? "done" : "failed"
-  });
-  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,
-  backlog_rank,
-  run_pause_comment,
-  backlog_next
-};