@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-VLDPUHGE.js

@@ -0,0 +1,134 @@
+import {
+  git_argv
+} from "./chunk-ZEVI2ZGI.js";
+
+// scripts/rules/gh-api.ts
+var GH_FLAGS = String.raw`(?:-{1,2}[\w-]+(?:[= ][^\s]+)?\s+)*`;
+var GH_API_COMMAND = new RegExp(String.raw`^gh\s+${GH_FLAGS}api\s`, "u");
+var GH_COMMAND = "gh";
+var METHOD_FLAGS = /* @__PURE__ */ new Set(["-X", "--method"]);
+var ATTACHED_METHOD = /^(?:-X=?|--method=)([A-Za-z]+)$/u;
+var FIELD_FLAGS = /* @__PURE__ */ new Set(["-f", "-F", "--field", "--raw-field", "--input"]);
+var ATTACHED_FIELD = /^(?:-[fF].|--(?:raw-field|field|input)=)/u;
+var QUOTES = /['"]/gu;
+var FLAG_PREFIX = "-";
+var NEXT = 1;
+var READ_METHOD = "GET";
+var API_VALUE_TAKING_FLAGS = /* @__PURE__ */ new Set([
+  "-R",
+  "--repo",
+  ...METHOD_FLAGS,
+  ...FIELD_FLAGS,
+  "-H",
+  "--header",
+  "-q",
+  "--jq",
+  "-t",
+  "--template",
+  "--hostname",
+  "-p",
+  "--preview",
+  "--cache"
+]);
+var INCLUDE_CLUSTER = /^-i+(?=[A-Za-z])/u;
+var REPO_PATH = /repos\/([^/\s'"?]+)\/([^/\s'"?]+)/u;
+var OWNER_GROUP = 1;
+var REPO_GROUP = 2;
+var OWNER_PLACEHOLDERS = /* @__PURE__ */ new Set(["{owner}", ":owner"]);
+function is_gh_api(segment) {
+  return GH_API_COMMAND.test(segment);
+}
+function flags_of(segment) {
+  const words = (git_argv.arguments_of(segment, GH_COMMAND) ?? []).map(
+    (word) => word.replace(INCLUDE_CLUSTER, "-")
+  );
+  let has_value_pending = false;
+  return words.map((word, index) => [word, words[index + NEXT] ?? ""]).filter(([word]) => {
+    if (has_value_pending) {
+      has_value_pending = false;
+      return false;
+    }
+    has_value_pending = API_VALUE_TAKING_FLAGS.has(word);
+    return word.startsWith(FLAG_PREFIX);
+  });
+}
+function method_value(flag, next) {
+  if (METHOD_FLAGS.has(flag)) return next.replaceAll(QUOTES, "");
+  return ATTACHED_METHOD.exec(flag)?.[1];
+}
+function method_of(segment) {
+  const methods = flags_of(segment).map(([flag, next]) => method_value(flag, next));
+  return methods.findLast((method) => method !== void 0)?.toUpperCase();
+}
+function is_field_flag(flag) {
+  return FIELD_FLAGS.has(flag) || ATTACHED_FIELD.test(flag);
+}
+function is_read(segment) {
+  const method = method_of(segment);
+  if (method !== void 0) return method === READ_METHOD;
+  return flags_of(segment).every(([flag]) => !is_field_flag(flag));
+}
+function is_write(segment) {
+  return !is_read(segment);
+}
+var INPUT_FLAG = "--input";
+var READS_FILE_FLAGS = /* @__PURE__ */ new Set(["-F", "--field"]);
+var ATTACHED_PARTS = /^(-[fF]|--(?:raw-field|field|input))=?(.+)$/u;
+var ATTACHED_FLAG_GROUP = 1;
+var ATTACHED_VALUE_GROUP = 2;
+var FILE_PREFIX = "@";
+var STANDARD_INPUT = "-";
+var FIELD_KEY_END = "=";
+function field_parts(flag, next) {
+  if (FIELD_FLAGS.has(flag)) return [flag, next];
+  const match = ATTACHED_PARTS.exec(flag);
+  if (match === null) return void 0;
+  return [String(match[ATTACHED_FLAG_GROUP]), String(match[ATTACHED_VALUE_GROUP])];
+}
+function field_value(value) {
+  return value.slice(value.indexOf(FIELD_KEY_END) + NEXT);
+}
+function file_path(flag, value) {
+  if (flag === INPUT_FLAG) return value;
+  const sent = field_value(value);
+  if (!READS_FILE_FLAGS.has(flag) || !sent.startsWith(FILE_PREFIX)) return void 0;
+  return sent.slice(FILE_PREFIX.length);
+}
+function field_source(flag, raw) {
+  const value = raw.replaceAll(QUOTES, "");
+  const path = file_path(flag, value);
+  if (path === void 0) return { kind: "text", value: field_value(value) };
+  return path === STANDARD_INPUT ? void 0 : { kind: "file", value: path };
+}
+function field_sources(segment) {
+  return flags_of(segment).flatMap(([flag, next]) => {
+    const parts = field_parts(flag, next);
+    const source = parts === void 0 ? void 0 : field_source(...parts);
+    return source === void 0 ? [] : [source];
+  });
+}
+function repo_target(segment) {
+  const match = REPO_PATH.exec(segment);
+  if (match === null) return void 0;
+  return { owner: match[OWNER_GROUP] ?? "", repo: match[REPO_GROUP] ?? "" };
+}
+function is_owner_placeholder(owner) {
+  return OWNER_PLACEHOLDERS.has(owner);
+}
+var gh_api = {
+  API_VALUE_TAKING_FLAGS,
+  FIELD_FLAGS,
+  GH_FLAGS,
+  METHOD_FLAGS,
+  field_sources,
+  is_gh_api,
+  is_owner_placeholder,
+  is_read,
+  is_write,
+  method_of,
+  repo_target
+};
+
+export {
+  gh_api
+};

package/dist/commands/chunk-VMMNYTET.js

@@ -0,0 +1,61 @@
+import {
+  run_preflight
+} from "./chunk-ZNFVJETO.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/git/stash/stash-orphans.ts
+var HASH_PATTERN = /#(?<issue>\d+)\b/u;
+var LEADING_PATTERN = /(?:^|: )(?<issue>\d+): /u;
+var MESSAGE_PATTERNS = [HASH_PATTERN, LEADING_PATTERN];
+var ALL_ISSUE_PATTERN = new RegExp(HASH_PATTERN.source, "gu");
+var BRANCH_PATTERN = /^(?:WIP on|On) (?<issue>\d+)-lane: /u;
+var WIP_PREFIX = "WIP on ";
+var NO_PATTERNS = [];
+var HEADER = "Stashes whose issue is closed, or whose owner cannot be read \u2014 decide for each whether to revive or discard it (none is dropped automatically):";
+var FOOTER = 'Revive: `pnpm josh stash:pop "<message>"` \xB7 Discard: `git stash drop <selector>` \u2014 re-read the selector first, the stack is shared by every lane.';
+var UNKNOWN_OWNER = "owner unknown";
+var COLUMN_SEPARATOR = "  ";
+var LINE_SEPARATOR = "\n";
+function patterns_for(subject) {
+  if (subject.includes(run_preflight.STASH_LABEL_PREFIX)) return NO_PATTERNS;
+  return subject.startsWith(WIP_PREFIX) ? [BRANCH_PATTERN] : [...MESSAGE_PATTERNS, BRANCH_PATTERN];
+}
+function issue_of(subject) {
+  for (const pattern of patterns_for(subject)) {
+    const issue = pattern.exec(subject)?.groups?.["issue"];
+    if (issue !== void 0) return issue;
+  }
+  return void 0;
+}
+function issues_of(entries) {
+  const issues = entries.map((entry) => issue_of(entry.subject));
+  return [...new Set(issues.filter((issue) => issue !== void 0))];
+}
+function message_issues(subject) {
+  const hashed = [...subject.matchAll(ALL_ISSUE_PATTERN)].map((match) => match.groups?.["issue"]);
+  return [...hashed, LEADING_PATTERN.exec(subject)?.groups?.["issue"]];
+}
+function issues_named(subject) {
+  const branch = BRANCH_PATTERN.exec(subject)?.groups?.["issue"];
+  const named = subject.startsWith(WIP_PREFIX) ? [] : message_issues(subject);
+  const found = [...named, branch].filter((issue) => issue !== void 0);
+  return [...new Set(found)];
+}
+function orphans(entries, closed) {
+  return entries.map((entry) => ({ ...entry, issue: issue_of(entry.subject) })).filter((entry) => entry.issue === void 0 || closed.has(entry.issue));
+}
+function format_line(orphan) {
+  const owner = orphan.issue === void 0 ? UNKNOWN_OWNER : `${session_cite.issue(orphan.issue)} closed`;
+  return `  ${[orphan.selector, owner, orphan.subject].join(COLUMN_SEPARATOR)}`;
+}
+function format_report(found) {
+  if (found.length === 0) return void 0;
+  return [HEADER, ...found.map((orphan) => format_line(orphan)), FOOTER].join(LINE_SEPARATOR);
+}
+var stash_orphans = { format_report, issue_of, issues_named, issues_of, orphans };
+
+export {
+  stash_orphans
+};

package/dist/commands/chunk-VO2GSW5P.js

@@ -0,0 +1,99 @@
+import {
+  bash_triggers
+} from "./chunk-25LVQDOF.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  gh_api
+} from "./chunk-VLDPUHGE.js";
+import {
+  git_argv
+} from "./chunk-ZEVI2ZGI.js";
+
+// scripts/rules/direct-pr-create.ts
+var GH_COMMAND = "gh";
+var PR_GROUP = "pr";
+var PR_CREATE_ACTIONS = /* @__PURE__ */ new Set(["create", "new"]);
+var FLAG_PREFIX = "-";
+var HELP_FLAGS = /* @__PURE__ */ new Set(["-h", "--help"]);
+var VALUE_TAKING_FLAGS = /* @__PURE__ */ new Set(["-R", "--repo"]);
+var { API_VALUE_TAKING_FLAGS } = gh_api;
+var API_SUBCOMMAND = "api";
+var PULLS_PATH = /^['"]?(?:https:\/\/api\.github\.com)?\/?repos\/[^/\s'"]+\/[^/\s'"]+\/pulls\/?['"]?$/u;
+function positional_words(args, value_taking_flags) {
+  return args.filter((argument, index) => {
+    if (argument.startsWith(FLAG_PREFIX)) return false;
+    return !value_taking_flags.has(args[index - 1] ?? "");
+  });
+}
+function is_pr_create_api_call(args) {
+  const call = [GH_COMMAND, ...args].join(" ");
+  if (!gh_api.is_gh_api(call) || !gh_api.is_write(call)) return false;
+  const [subcommand, endpoint = ""] = positional_words(args, API_VALUE_TAKING_FLAGS);
+  return subcommand === API_SUBCOMMAND && PULLS_PATH.test(endpoint);
+}
+function is_pr_create_cli_call(args) {
+  const [group, action = ""] = positional_words(args, VALUE_TAKING_FLAGS);
+  return group === PR_GROUP && PR_CREATE_ACTIONS.has(action);
+}
+function is_help_call(args) {
+  return args.some(
+    (argument, index) => HELP_FLAGS.has(argument) && !(args[index - 1] ?? "").startsWith(FLAG_PREFIX)
+  );
+}
+function is_pr_create_segment(segment) {
+  const args = git_argv.arguments_of(segment, GH_COMMAND);
+  if (args === void 0 || is_help_call(args)) return false;
+  return is_pr_create_cli_call(args) || is_pr_create_api_call(args);
+}
+var RUNS_QUOTED_TEXT = /\$\(|`/u;
+var QUOTED_TEXT_RUNNERS = /* @__PURE__ */ new Set(["ssh", "eval"]);
+var SHELL_DASH_C = /\b(?:ba|da|k|z)?sh\s+(?:-\S+\s+)*-[A-Za-z]*c\b/u;
+var COMMENT_MARKER = /(?:^|\s)#/mu;
+var LINE_BREAK = "\n";
+function is_run_by_shell(segment) {
+  if (RUNS_QUOTED_TEXT.test(segment) || SHELL_DASH_C.test(segment)) return true;
+  return QUOTED_TEXT_RUNNERS.has(git_argv.program_of(segment)?.name ?? "");
+}
+function is_runs_quoted_text(segment) {
+  if (is_run_by_shell(segment)) return true;
+  return segment.includes(LINE_BREAK) && COMMENT_MARKER.test(segment);
+}
+function judged_segments(segment) {
+  return is_runs_quoted_text(segment) ? shell_segments.commands_of(segment) : [segment];
+}
+function has_run_segment(command, is_match) {
+  return shell_segments.quote_aware_commands_of(command).flatMap((segment) => judged_segments(segment)).some((segment) => is_match(segment));
+}
+function is_direct_pr_create(command) {
+  return has_run_segment(command, is_pr_create_segment);
+}
+var DIRECT_PR_CREATE_REASON = '\u26D4 direct PR creation: `gh pr create` (or a `gh api` POST to `repos/<o>/<r>/pulls`) bypasses `build_body`, which writes the `closes #N` line \u2014 the Issue would stay open after the merge (`operating-rules.md` \u2192 "git-rules"). Open the PR with `pnpm josh pr` instead; after a failed push, fix, push, then run `pnpm josh pr`. **This rule fires on every occurrence, not once per run.**';
+var ROW = {
+  id: "direct-pr-create",
+  is_trigger: bash_triggers.on_bash_command(is_direct_pr_create),
+  reason: DIRECT_PR_CREATE_REASON,
+  decide: () => true,
+  about: {
+    title: "Direct PR creation",
+    topic: '`operating-rules.md` \u2192 "git-rules"',
+    fires: "`gh pr create`, or a `gh api` write to `repos/<o>/<r>/pulls`; it points at `pnpm josh pr`. Every occurrence",
+    quiet: "`pnpm josh pr`, or reading a PR \u2014 the path that writes `closes #N`"
+  }
+};
+var direct_pr_create = {
+  API_VALUE_TAKING_FLAGS,
+  DIRECT_PR_CREATE_REASON,
+  GH_COMMAND,
+  ROW,
+  VALUE_TAKING_FLAGS,
+  has_run_segment,
+  is_direct_pr_create,
+  is_help_call,
+  positional_words
+};
+
+export {
+  direct_pr_create
+};

package/dist/commands/chunk-VP3P7FLJ.js

@@ -0,0 +1,168 @@
+import {
+  epic_audit_logic
+} from "./chunk-RVFE7JDZ.js";
+import {
+  report_format_reference
+} from "./chunk-Q6SKKQVJ.js";
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/review/acceptance-map.ts
+import { createHash } from "node:crypto";
+var MAP_HEADING = "## \u53D7\u3051\u5165\u308C\u6761\u4EF6\u306E\u5BFE\u5FDC";
+var MET = "\u6E80\u305F\u3057\u305F";
+var DEFERRED = "\u898B\u9001\u308A";
+var PENDING = "\u672A\u8A18\u5165";
+var PENDING_SUFFIX = `\u2014 ${PENDING}`;
+var ID_PREFIX = "ac-";
+var ID_HEX_LENGTH = 8;
+var BACKTICK = "`";
+var CRITERION_PATTERN = /^(?:[-*+]|\d+\.)\s+(?:\[[ xX]\]\s+)?(?<text>\S.*)$/u;
+var BLOCK_START_PATTERN = /^\s*(?:(?:[-*+]|\d+\.)\s|#|\||<!--)/u;
+var ROW_PATTERN = new RegExp(
+  String.raw`^[-*]\s+${BACKTICK}(?<id>${ID_PREFIX}[0-9a-f]{${String(ID_HEX_LENGTH)}})${BACKTICK}(?:\s.*)?\s(?<kind>${MET}|${DEFERRED}):\s*(?<rest>\S.*)$`,
+  "u"
+);
+var PENDING_ROW_PATTERN = new RegExp(
+  String.raw`^[-*]\s+${BACKTICK}(?<id>${ID_PREFIX}[0-9a-f]{${String(ID_HEX_LENGTH)}})${BACKTICK}.*\s${PENDING_SUFFIX}$`,
+  "u"
+);
+var DEFERRAL_PATTERN = /^(?<issue>(?:[\w.-]+\/[\w.-]+)?#\d+)\s+\S/u;
+var ROW_FORMAT = `under ${MAP_HEADING}, one line per acceptance criterion: \`- \`<id>\` <criterion> \u2014 ${MET}: <test name, file:line or command output>\` or \`- \`<id>\` <criterion> \u2014 ${DEFERRED}: #<split-off issue> <reason>\``;
+function criterion_id(text) {
+  const normalized = text.replaceAll(/\s+/gu, " ").trim();
+  const digest = createHash("sha256").update(normalized).digest("hex");
+  return `${ID_PREFIX}${digest.slice(0, ID_HEX_LENGTH)}`;
+}
+function joins(last, line) {
+  const is_continuation = line.trim() !== "" && !BLOCK_START_PATTERN.test(line);
+  return is_continuation && CRITERION_PATTERN.test(last);
+}
+function append_line(items, line, index) {
+  const last = items.at(-1);
+  if (last !== void 0 && joins(last.text, line)) last.text += ` ${line.trim()}`;
+  else items.push({ text: line, index });
+}
+function unwrapped(lines) {
+  const items = [];
+  for (const [index, line] of lines.entries()) {
+    append_line(items, line, index);
+  }
+  return items;
+}
+function criteria_of(issue_body) {
+  const lines = markdown_section.fence_free_lines(epic_audit_logic.acceptance_section(issue_body));
+  const texts = unwrapped(lines).map((line) => CRITERION_PATTERN.exec(line.text)?.groups?.["text"]);
+  return texts.filter((text) => text !== void 0).map((text) => ({ id: criterion_id(text), text: text.trim() }));
+}
+function selected_line(line, ids) {
+  const text = CRITERION_PATTERN.exec(line.text)?.groups?.["text"];
+  return text !== void 0 && ids.has(criterion_id(text));
+}
+function tick_line(line) {
+  const checkbox = /^(?<prefix>(?:[-*+]|\d+\.)\s+)\[[ xX]\]/u;
+  if (!checkbox.test(line)) throw new Error("Selected acceptance criterion has no checkbox");
+  return line.replace(/^(?<prefix>(?:[-*+]|\d+\.)\s+)\[ \]/u, "$<prefix>[x]");
+}
+function tick_section(section, ids) {
+  const visible = markdown_section.fence_free_lines(section);
+  const selected = new Set(
+    unwrapped(visible).filter((line) => selected_line(line, ids)).map((line) => line.index)
+  );
+  return section.split("\n").map((line, index) => selected.has(index) ? tick_line(line) : line).join("\n");
+}
+function tick(body, ids) {
+  const criteria = criteria_of(body);
+  const unknown = ids.filter((id) => criteria.every((criterion) => criterion.id !== id));
+  if (unknown.length > 0) throw new Error(`Unknown acceptance criteria: ${unknown.join(", ")}`);
+  return markdown_section.map_section(
+    body,
+    epic_audit_logic.is_acceptance_heading,
+    (section) => tick_section(section, new Set(ids))
+  );
+}
+function deferral_of(id, rest) {
+  const issue = DEFERRAL_PATTERN.exec(rest)?.groups?.["issue"];
+  return issue === void 0 ? void 0 : { id, issue };
+}
+function group(groups, name) {
+  return groups[name] ?? "";
+}
+function row_of(line) {
+  const trimmed = line.trim();
+  if (trimmed.endsWith(PENDING_SUFFIX)) return void 0;
+  const groups = ROW_PATTERN.exec(trimmed)?.groups;
+  if (groups === void 0) return void 0;
+  return { id: group(groups, "id"), kind: group(groups, "kind"), rest: group(groups, "rest") };
+}
+function rows_of(pr_body = "") {
+  const rows = markdown_section.fence_free_lines(markdown_section.section_lines(pr_body, MAP_HEADING).join("\n")).map((line) => row_of(line)).filter((row) => row !== void 0);
+  const met = rows.filter((row) => row.kind === MET).map((row) => row.id);
+  const deferrals = rows.filter((row) => row.kind === DEFERRED).map((row) => deferral_of(row.id, row.rest)).filter((deferral) => deferral !== void 0);
+  return { met: new Set(met), deferrals, ids: /* @__PURE__ */ new Set([...met, ...deferrals.map((row) => row.id)]) };
+}
+function compare(criteria, rows) {
+  const current = new Set(criteria.map((criterion) => criterion.id));
+  return {
+    missing: criteria.filter((criterion) => !rows.ids.has(criterion.id)),
+    deferrals: rows.deferrals.filter((deferral) => current.has(deferral.id)),
+    stale: [...rows.ids].filter((id) => !current.has(id))
+  };
+}
+function skeleton(issue_body) {
+  const criteria = criteria_of(issue_body);
+  if (criteria.length === 0) return void 0;
+  const rows = criteria.map(
+    (criterion) => `- \`${criterion.id}\` ${criterion.text} ${PENDING_SUFFIX}`
+  );
+  return [MAP_HEADING, "", ...rows].join("\n");
+}
+function met_line(line, titles) {
+  const id = PENDING_ROW_PATTERN.exec(line.trim())?.groups?.["id"];
+  const title = id === void 0 ? void 0 : titles.find((candidate) => candidate.includes(id));
+  if (title === void 0) return line;
+  return `${line.trimEnd().slice(0, -PENDING.length)}${MET}: ${BACKTICK}${title}${BACKTICK}`;
+}
+function with_test_rows(body, titles) {
+  return body.split("\n").map((line) => met_line(line, titles)).join("\n");
+}
+function has_map(pr_body = "") {
+  return markdown_section.has_unfenced_line(pr_body, MAP_HEADING);
+}
+function listed(title, lines) {
+  return lines.length === 0 ? [] : [title, ...lines.map((line) => `  ${line}`)];
+}
+function refusal_message(issue, comparison, absent) {
+  return [
+    `The pull request body does not map every acceptance criterion of ${session_cite.issue(issue)} as it reads now, so the merge is refused.`,
+    ...listed(
+      "Criteria with no row (added or reworded since the body was written, or never mapped):",
+      comparison.missing.map((criterion) => `- \`${criterion.id}\` ${criterion.text}`)
+    ),
+    ...listed("Deferral rows naming an issue that could not be found:", absent),
+    ...listed("Rows naming no current criterion:", comparison.stale),
+    `Write ${ROW_FORMAT} \u2014 format: ${report_format_reference.pointer(report_format_reference.ACCEPTANCE_MAP_HEADING)}`,
+    "Write it into the `--body-file` before `josh ship`, or update an open PR with `gh api -X PATCH repos/{owner}/{repo}/pulls/<N> -F body=@<path>`, then re-run."
+  ].join("\n");
+}
+var acceptance_map = {
+  MAP_HEADING,
+  compare,
+  criteria_of,
+  criterion_id,
+  has_map,
+  refusal_message,
+  ROW_FORMAT,
+  rows_of,
+  skeleton,
+  with_test_rows,
+  tick
+};
+
+export {
+  acceptance_map
+};

package/dist/commands/chunk-VRS252GW.js

@@ -0,0 +1,88 @@
+import {
+  issue_run_hold
+} from "./chunk-QX2R6UJG.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  open_issue_schema
+} from "./chunk-34DND4BA.js";
+import {
+  IN_PROGRESS_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  read_json_listing
+} from "./chunk-NAZ753DE.js";
+
+// scripts/epic/epic-busy.ts
+var LISTING_LIMIT = 100;
+var NO_AGES = /* @__PURE__ */ new Map();
+function format_holder(issue, repo, ages) {
+  const cite = session_cite.issue(issue.number, issue.title, repo);
+  const age = ages.get(issue.number);
+  return age === void 0 ? cite : `${cite} (${age})`;
+}
+function format_holders(issues, repo, ages) {
+  return issues.map((issue) => format_holder(issue, repo, ages)).join(", ");
+}
+function occupied_lanes(read) {
+  return read.kind === "busy" ? read.issues.length : 0;
+}
+function occupancy_message(issues, repo, limit, ages = NO_AGES) {
+  return `${String(issues.length)} of ${String(limit)} lanes in use in ${repo}: ${format_holders(issues, repo, ages)}.`;
+}
+function lanes_full_message(issues, repo, limit, ages = NO_AGES) {
+  return `${occupancy_message(issues, repo, limit, ages)} No lane is free, so nothing is offered here. A lane is released when its child merges or is parked; if a label is stale, remove it and ask again, and \`JOSH_LANE_LIMIT\` is what raises the ceiling.`;
+}
+function unreadable_message(repo) {
+  return `Could not read the \`${IN_PROGRESS_LABEL}\` listing for ${repo}. That is not "nothing is running" \u2014 check \`gh auth status\` and ask again.`;
+}
+function truncated_message(repo) {
+  return `\u26A0 The \`${IN_PROGRESS_LABEL}\` listing for ${repo} could not be read to the end, so an issue holding that repository may not be in it. That is not "nothing is running" \u2014 nothing is offered here, and asking again will not clear it. Narrow what carries \`${IN_PROGRESS_LABEL}\` in that repository, or run this child there by hand.`;
+}
+var BUSY_REASONS = {
+  unreadable: unreadable_message,
+  truncated: truncated_message
+};
+function busy_reason(read, repo, limit, ages = NO_AGES) {
+  if (read.kind === "busy") return lanes_full_message(read.issues, repo, limit, ages);
+  if (read.kind === "idle") return "";
+  return BUSY_REASONS[read.kind](repo);
+}
+function is_holder(issue) {
+  return issue_run_hold.is_held((issue.labels ?? []).map((label) => label.name));
+}
+function parse_listing(raw, is_capped) {
+  const read = read_json_listing(raw, open_issue_schema);
+  if (read.kind !== "read") return { kind: "unreadable" };
+  const holders = read.rows.filter((row) => is_holder(row));
+  if (holders.length > 0) return { kind: "busy", issues: holders };
+  return { kind: is_capped ? "truncated" : "idle" };
+}
+async function read_repository(repo) {
+  const { json, is_capped } = await git_gh_command.issue_list_by_label_in_repo(
+    IN_PROGRESS_LABEL,
+    LISTING_LIMIT,
+    repo
+  );
+  return json === void 0 ? { kind: "unreadable" } : parse_listing(json, is_capped);
+}
+var epic_busy = {
+  LISTING_LIMIT,
+  occupied_lanes,
+  occupancy_message,
+  lanes_full_message,
+  unreadable_message,
+  truncated_message,
+  busy_reason,
+  is_holder,
+  parse_listing,
+  read_repository
+};
+
+export {
+  epic_busy
+};