@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-MRAEJLXL.js

@@ -0,0 +1,83 @@
+import {
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  SPLIT_ROUTE_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+
+// scripts/split/split-resolution.ts
+var NOTICE_SECTION = `split-assessment.md \u2192 "${split_assess.NOTICE_SECTION}"`;
+function is_split_clear({ route, found_during }) {
+  const marked = lane_child_marker.marked_issue();
+  const finder = found_during ?? marked;
+  if (route !== SPLIT_ROUTE_LABEL || finder === void 0 || finder !== marked) return true;
+  console.error(
+    `refused: ${session_cite.issue(finder)} is a dispatched lane, which is never split \u2014 finish it; file an independent new requirement without \`--route split\` (${NOTICE_SECTION}).`
+  );
+  return false;
+}
+function is_notice(entry) {
+  return entry.kind === lane_ledger.KIND.SPLIT_NOTICE;
+}
+function is_split_child(entry) {
+  return entry.kind === lane_ledger.KIND.SPLIT_FILED;
+}
+function notices(entries) {
+  return entries.filter((entry) => is_notice(entry));
+}
+function split_issues(entries) {
+  return new Set(entries.filter((entry) => is_split_child(entry)).map((entry) => entry.issue));
+}
+async function record_child({ route, found_during, child }) {
+  if (route !== SPLIT_ROUTE_LABEL || found_during === void 0) return;
+  try {
+    await lane_ledger_write.record_split_filed({ issue: Number(found_during), child });
+  } catch (error) {
+    throw new Error(
+      `Created ${child}, but split-child evidence could not be recorded. Do not create another child. Recover with \`pnpm josh split:recover ${found_during} ${child}\`.`,
+      { cause: error }
+    );
+  }
+}
+async function record_fold({ origin, target }) {
+  try {
+    await lane_ledger_write.record_split_filed({
+      issue: Number(origin),
+      child: issue_cite.plain_for("program", target)
+    });
+  } catch (error) {
+    throw new Error(
+      `Folded into ${session_cite.issue(target)}, but split-child evidence for ${session_cite.issue(origin)} could not be recorded: ${error_text.message_of(error)}`,
+      { cause: error }
+    );
+  }
+}
+var split_resolution = {
+  is_split_clear,
+  notices,
+  record_child,
+  record_fold,
+  split_issues
+};
+
+export {
+  split_resolution
+};

package/dist/commands/chunk-MRW2WYJS.js

@@ -0,0 +1,68 @@
+import {
+  plan_consumers_section
+} from "./chunk-SRG6PKVS.js";
+import {
+  backlog_overlap,
+  lane_plan
+} from "./chunk-MDGPJOLK.js";
+import {
+  issue_read
+} from "./chunk-3F3RNIG2.js";
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  git_gh_issue_read
+} from "./chunk-TFYYXETQ.js";
+import {
+  PLANNED_LABEL,
+  has_any_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  bounded_pool
+} from "./chunk-EBVS2LKX.js";
+
+// scripts/backlog/backlog-plan-comment.ts
+var PLANNED = /* @__PURE__ */ new Set([PLANNED_LABEL]);
+var READ_CONCURRENCY = 8;
+function is_plan(comment) {
+  return comment.is_trusted === true && markdown_section.has_line(comment.body, plan_consumers_section.HEADING);
+}
+function plan_body(comment) {
+  return comment === void 0 ? void 0 : plan_consumers_section.without(comment.body);
+}
+function plan_of(comments) {
+  return plan_body(comments.findLast((comment) => is_plan(comment)));
+}
+async function read_plan_comment(issue) {
+  const json = await git_gh_issue_read.issue_list_comments(String(issue));
+  const comments = await issue_read.parse_comments(json);
+  return comments?.findLast((comment) => is_plan(comment));
+}
+async function read_plan(issue) {
+  return plan_body(await read_plan_comment(issue));
+}
+async function plan_paths(issue) {
+  return [...backlog_overlap.declared_paths(await read_plan(issue) ?? "")];
+}
+async function with_plan(issue) {
+  if (!has_any_label(issue.labels, PLANNED)) return issue;
+  const comment = await read_plan_comment(issue.number);
+  const plan = plan_body(comment);
+  if (plan === void 0 || backlog_overlap.declared_paths(plan).size === 0) return issue;
+  return { ...issue, body: plan, commented_at: comment?.created_at };
+}
+function commented_of(planned) {
+  const dated = planned.filter((issue) => issue.commented_at !== void 0);
+  return new Map(dated.map((issue) => [issue.number, issue.commented_at ?? ""]));
+}
+async function declared_of(issues, directory) {
+  const planned = await bounded_pool.bounded_map(issues, READ_CONCURRENCY, with_plan);
+  const declared = backlog_overlap.declared_of(planned);
+  return lane_plan.with_plans(declared, directory, commented_of(planned));
+}
+var backlog_plan_comment = { declared_of, plan_of, plan_paths, read_plan };
+
+export {
+  backlog_plan_comment
+};

package/dist/commands/chunk-MXPCEZL5.js

@@ -0,0 +1,23 @@
+// scripts/backlog/backlog-hold-codes.ts
+var OFFER_PREFIX = "offer";
+var HAND_BACK_PREFIX = "hand-back";
+var REASON_SEPARATOR = ":";
+var USAGE_LIMIT_REASON = "usage-limit";
+var MEMORY_REASON = "memory";
+var DRIVERLESS_PREFIX = "driverless:";
+var WATCH_VERDICT = "watch";
+var DRAINED_REASON = "drained";
+var backlog_hold_codes = {
+  DRAINED_REASON,
+  DRIVERLESS_PREFIX,
+  HAND_BACK_PREFIX,
+  MEMORY_REASON,
+  OFFER_PREFIX,
+  REASON_SEPARATOR,
+  USAGE_LIMIT_REASON,
+  WATCH_VERDICT
+};
+
+export {
+  backlog_hold_codes
+};

package/dist/commands/chunk-N2XH7QBY.js

@@ -0,0 +1,103 @@
+import {
+  run_cut
+} from "./chunk-TFDVTU6O.js";
+import {
+  RUN_STALLED_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/run/park/run-stalled.ts
+var SESSION_UNFINISHED = {
+  short: "session unfinished",
+  why: "the child\u2019s session ended with its issue still open and unfinished."
+};
+var CUT_NOT_RELAUNCHED = {
+  short: "cut not relaunched",
+  why: "its lane held a declared cut, but no successor could be relaunched from it (or it already was once)."
+};
+var STALE_HANDOFF = {
+  short: "stale hand-off",
+  why: "the child stopped at `resume: handed-off` because an old hand-off cut record was already adopted."
+};
+var RESUME_COMMAND = "fullrun";
+var CAUSE_LEAD = `${RUN_STALLED_LABEL}: `;
+function resume_of(child, is_backlog_live = false) {
+  return is_backlog_live ? `pnpm josh run:add ${String(child)} --retry` : `${RESUME_COMMAND} ${issue_cite.plain_for("program", child)}`;
+}
+function recovery_of(cause) {
+  if (cause === STALE_HANDOFF.why) {
+    return `repair the stale hand-off cut record with \`${run_cut.END_COMMAND}\` (retry alone does not clear it)`;
+  }
+  return /cut.*(?:handed-off|already handed off)/iu.test(cause) ? `clear the handed-off cut with \`${run_cut.END_COMMAND}\`` : "fix the cause";
+}
+function next_step(child, cause = "") {
+  const recovery = recovery_of(cause);
+  return `${recovery}, then use \`${resume_of(child, true)}\` in the live backlogrun or resume it with \`${resume_of(child, false)}\``;
+}
+var ESCALATION_REQUESTED = {
+  short: "escalation requested",
+  why: "the worker declared that its Issue needs a stronger josh.worker profile."
+};
+var CARRYING_CLASSES = [SESSION_UNFINISHED, ESCALATION_REQUESTED];
+function lead_of(cause) {
+  return `${cause.short}: `;
+}
+function carrying(cause, message) {
+  const first = message.split(/\r?\n/u, 1)[0]?.trim() ?? "";
+  return first === "" ? cause : { short: `${lead_of(cause)}${first}`, why: first };
+}
+function session_unfinished(message) {
+  return carrying(SESSION_UNFINISHED, message);
+}
+function escalation_requested(reason) {
+  return carrying(ESCALATION_REQUESTED, reason);
+}
+function class_of(cause) {
+  const carried = CARRYING_CLASSES.find((known) => cause.startsWith(lead_of(known)));
+  return carried?.short ?? cause;
+}
+function park_event(child, cause) {
+  return `${issue_cite.plain_for("program", child)} parked (${CAUSE_LEAD}${cause})`;
+}
+function cause_of(reason) {
+  if (reason === RUN_STALLED_LABEL) return "";
+  return reason.startsWith(CAUSE_LEAD) ? reason.slice(CAUSE_LEAD.length) : void 0;
+}
+function cause_in(text) {
+  const lead = ` parked (${CAUSE_LEAD}`;
+  const start = text.indexOf(lead);
+  return start === -1 || !text.endsWith(")") ? void 0 : text.slice(start + lead.length, -1);
+}
+function stop_of(event) {
+  return event.stop;
+}
+function row_text(child, cause = "", is_backlog_live = false) {
+  const resume = `\u2192 resume: ${resume_of(child, is_backlog_live)}`;
+  return cause === "" ? resume : `${resume} (${cause})`;
+}
+function waiting_text(waits) {
+  return `waiting on ${waits.map((wait) => wait.includes("#") ? wait : issue_cite.plain_for("program", wait)).join(", ")}`;
+}
+var run_stalled = {
+  CUT_NOT_RELAUNCHED,
+  ESCALATION_REQUESTED,
+  SESSION_UNFINISHED,
+  STALE_HANDOFF,
+  cause_in,
+  cause_of,
+  class_of,
+  escalation_requested,
+  next_step,
+  park_event,
+  resume_of,
+  row_text,
+  session_unfinished,
+  stop_of,
+  waiting_text
+};
+
+export {
+  run_stalled
+};

package/dist/commands/chunk-N2ZF6T4E.js

@@ -0,0 +1,332 @@
+import {
+  epic_report
+} from "./chunk-4HOTJAO6.js";
+import {
+  epic_triage
+} from "./chunk-VQRT32JB.js";
+import {
+  auto_ok_cli,
+  epic_bundle_gaps
+} from "./chunk-RFIOZTXY.js";
+import {
+  run_prep_locate
+} from "./chunk-XRQMVAB4.js";
+import {
+  epic_cross_repo
+} from "./chunk-YTXCLGGL.js";
+import {
+  issue_not_before
+} from "./chunk-PCZROH3R.js";
+import {
+  size_estimate
+} from "./chunk-2VY7CJ2R.js";
+import {
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+import {
+  IN_PROGRESS_LABEL,
+  SPLIT_ROUTE_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  issue_citation,
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  line_budget
+} from "./chunk-QFIKPGMC.js";
+
+// 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 here = children.filter((child) => child.repo === repo);
+  return {
+    chain: numbers_with(here, "chain"),
+    gate: numbers_with(here, "gate"),
+    lane: numbers_with(here, "lane"),
+    ...deadline_of(here)
+  };
+}
+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 here = epic_report.candidates_for_repo(result, repo);
+  if (here.length === 0) return [VERDICT_TOKENS.wait];
+  return here.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
+};
+
+export {
+  issue_cap_files,
+  backlog_wait_cause,
+  backlog_next_report
+};

package/dist/commands/chunk-N36NZMAL.js

@@ -0,0 +1,79 @@
+import {
+  git_gh_pr_snapshot
+} from "./chunk-NRULNBYI.js";
+import {
+  issue_watch_diff
+} from "./chunk-GOY5JECO.js";
+import {
+  CHECK_STATUS_FAIL,
+  matches_any,
+  parse_pr_state_snapshot
+} from "./chunk-WVR4RUFP.js";
+import {
+  git_gh_issue_read
+} from "./chunk-TFYYXETQ.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/run/run-pr-return.ts
+var HEADING = "=== returned for a fix ===";
+var RED_PREFIX = "red required check: ";
+var COMMENT_PREFIX = "read the comment by ";
+var AT = " at ";
+function red_required_checks(snapshot) {
+  const required = snapshot.required_contexts ?? [];
+  return snapshot.rollup.filter((check) => check.status === CHECK_STATUS_FAIL && matches_any(check.name, required)).map((check) => check.name);
+}
+function comments_since(comments, since_ms) {
+  return comments.filter(
+    (comment) => comment.is_trusted !== false && !comment.author.endsWith(issue_watch_diff.BOT_SUFFIX) && Date.parse(comment.created_at) > since_ms
+  );
+}
+async function last_work_ms(directory) {
+  const location = directory === void 0 ? [] : ["-C", directory];
+  const date = await git_spawn.read([
+    ...location,
+    "log",
+    "--first-parent",
+    "--no-merges",
+    "-1",
+    "--format=%cI"
+  ]);
+  return Date.parse(date);
+}
+function is_returned(pr_return) {
+  return pr_return.red_checks.length > 0 || pr_return.comments.length > 0;
+}
+function format(pr_return) {
+  if (!is_returned(pr_return)) return void 0;
+  const reds = pr_return.red_checks.map((name) => `${RED_PREFIX}${name}`);
+  const comments = pr_return.comments.map(
+    (comment) => `${COMMENT_PREFIX}${comment.author}${AT}${comment.created_at}`
+  );
+  return [HEADING, ...reds, ...comments].join("\n");
+}
+async function read_comments(issue) {
+  const json = await git_gh_issue_read.issue_list_comments(issue);
+  return await issue_watch_diff.parse_comments(json) ?? [];
+}
+async function read(issue, directory) {
+  const branch = directory === void 0 ? await git_command.branch() : await git_command.branch_at(directory);
+  const [snapshot_json, comments, since_ms] = await Promise.all([
+    git_gh_pr_snapshot.pr_get_state_snapshot(branch),
+    read_comments(issue),
+    last_work_ms(directory)
+  ]);
+  return {
+    red_checks: red_required_checks(parse_pr_state_snapshot(snapshot_json)),
+    comments: comments_since(comments, since_ms)
+  };
+}
+var run_pr_return = { comments_since, format, read, red_required_checks };
+
+export {
+  run_pr_return
+};