@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-YNCF66RK.js

@@ -0,0 +1,1052 @@
+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
+};