@joshuafolkken/kit 1.2116.0 → 1.3041.0

package/dist/commands/chunk-OWYK2BEJ.js

@@ -0,0 +1,1222 @@
+import {
+  backlog_triage_decision,
+  issue_run_verdict
+} from "./chunk-JV24VP2O.js";
+import {
+  run_event_filed
+} from "./chunk-PYOK73QE.js";
+import {
+  issue_classification,
+  issue_lint_cli
+} from "./chunk-MUGTOJUL.js";
+import {
+  issue_auto_ok
+} from "./chunk-QGATHT4S.js";
+import {
+  issue_scout_cli,
+  measure_twin
+} from "./chunk-LUXWDMKI.js";
+import {
+  epic_bundle_cli
+} from "./chunk-7NHZCI5Y.js";
+import {
+  issue_fold_cli
+} from "./chunk-352KLSFX.js";
+import {
+  epic_blocked_by
+} from "./chunk-KZ7HD37E.js";
+import {
+  split_resolution
+} from "./chunk-RUQY5TS3.js";
+import {
+  epic_shape
+} from "./chunk-XPBF5DG3.js";
+import {
+  epic_relations
+} from "./chunk-FQGWO2ZH.js";
+import {
+  epic_validate
+} from "./chunk-OP2RFVLS.js";
+import {
+  issue_fold
+} from "./chunk-2XAH3MHV.js";
+import {
+  issue_release_cli
+} from "./chunk-NEGJ77RV.js";
+import {
+  issue_state_cli
+} from "./chunk-BRHPRDDV.js";
+import {
+  repository_labels
+} from "./chunk-FOKCRIAN.js";
+import {
+  acceptance_map
+} from "./chunk-5PCK53WP.js";
+import {
+  run_hold_session
+} from "./chunk-SASX3W2M.js";
+import {
+  issue_cap_files,
+  issue_not_before_label
+} from "./chunk-KCFOP5RI.js";
+import {
+  lane_net_read
+} from "./chunk-MFBNNTBM.js";
+import {
+  epic_triage
+} from "./chunk-VQRT32JB.js";
+import {
+  issue_closing_pr
+} from "./chunk-KZSM5M5P.js";
+import {
+  issue_sample_gate
+} from "./chunk-CQUZ6TNQ.js";
+import {
+  epic_issue
+} from "./chunk-IAD4WLLI.js";
+import {
+  measure_declaration
+} from "./chunk-34JJYCIY.js";
+import {
+  size_estimate
+} from "./chunk-FDS65XOJ.js";
+import {
+  issue_priority
+} from "./chunk-XI2ABCRX.js";
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  github_issue_url
+} from "./chunk-S4X5PJV7.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  git_gh_command
+} from "./chunk-YGFOGA7C.js";
+import {
+  MAX_SCANNED,
+  git_gh_issue_list
+} from "./chunk-HXDTA5VU.js";
+import {
+  backlog_overlap
+} from "./chunk-B7ZNIEDV.js";
+import {
+  test_related_pins
+} from "./chunk-HE5S4XRE.js";
+import {
+  markdown_section
+} from "./chunk-JZK33TA5.js";
+import {
+  COMMAND_MAP
+} from "./chunk-C54QXJD6.js";
+import {
+  git_branch
+} from "./chunk-Q5Q2QYVU.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+import {
+  agent_worker_profile
+} from "./chunk-FVDQNMP6.js";
+import {
+  git_gh_issue_write
+} from "./chunk-RN2YDNLF.js";
+import {
+  git_gh_issue_rest
+} from "./chunk-ENKFCOVY.js";
+import {
+  repo_party
+} from "./chunk-6OP63TBT.js";
+import {
+  run_hold
+} from "./chunk-X3TNPALI.js";
+import {
+  run_event_stream_emit
+} from "./chunk-OKZWEVR4.js";
+import {
+  run_event_stream
+} from "./chunk-NSAVEXVR.js";
+import {
+  AUTO_OK_LABEL,
+  FILING_ROUTE_LABELS,
+  INTERRUPT_ROUTE_LABEL,
+  NEEDS_DECISION_LABEL,
+  RUN_LANE_LABEL,
+  RUN_SOLO_LABEL,
+  SPLIT_ROUTE_LABEL,
+  TIER_A_ROUTE_LABEL,
+  has_label_name,
+  has_parked_label
+} from "./chunk-QQBMVC5W.js";
+import {
+  lane_child_marker
+} from "./chunk-QAHFPCFR.js";
+import {
+  shell_quote
+} from "./chunk-W2IA2LV3.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  issue_number_shape
+} from "./chunk-66NX6EXR.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec
+} from "./chunk-XDF25GSU.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_command
+} from "./chunk-AKQYYHP2.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/hold/run-hold-member.ts
+function is_owned(hold, owner) {
+  if (hold.owner_pid === void 0 || owner.owner_pid === void 0) return false;
+  return run_hold_session.is_session_hold(hold, owner);
+}
+async function is_hold_owner(owner) {
+  const directory = await run_hold.worktree_directory();
+  if (directory === void 0) return false;
+  const read = run_hold.read_hold(run_hold.hold_path(directory));
+  return read.kind === "held" && is_owned(read.hold, owner);
+}
+async function is_run_member(owner = run_hold.session_owner()) {
+  if (lane_child_marker.marked_issue() !== void 0) return true;
+  return await is_hold_owner(owner);
+}
+var run_hold_member = { is_run_member };
+
+// scripts/split/split-direction.ts
+var KEPT_HEADINGS = [issue_body_keys.heading("expected"), issue_body_keys.heading("criteria")];
+var CODE_SPAN = /`([^`]+)`/gu;
+var NOT_A_NAME = /[\s:]/u;
+var LINE_SUFFIX = /:\d+(?:[-:]\d+)?$/u;
+var SEPARATOR = "/";
+var EXTENSION = /\.[^.]*$/u;
+var WORD = /\s+/u;
+var COMMAND_WORD = /[\w:-]+/gu;
+var COMMAND_SEPARATOR = ":";
+var MARKDOWN = /\.mdx?$/iu;
+function normalized(name) {
+  return name.replaceAll("_", "-");
+}
+function module_of(path) {
+  return normalized(path.slice(path.lastIndexOf(SEPARATOR) + 1).replace(EXTENSION, ""));
+}
+function stem_of(span) {
+  const name = span.replace(LINE_SUFFIX, "");
+  if (NOT_A_NAME.test(name)) return void 0;
+  const stem = name.slice(name.lastIndexOf(SEPARATOR) + 1).split(".", 1)[0] ?? "";
+  return stem === "" ? void 0 : normalized(stem);
+}
+function is_command(word) {
+  return word.includes(COMMAND_SEPARATOR) && Object.hasOwn(COMMAND_MAP, word);
+}
+function commands_of(span) {
+  return span.split(WORD).filter((word) => is_command(word));
+}
+function kept_names(body) {
+  const text = KEPT_HEADINGS.flatMap((heading) => markdown_section.section_lines(body, heading));
+  const spans = [...text.join("\n").matchAll(CODE_SPAN)].map((match) => match[1] ?? "");
+  const stems = spans.map((span) => stem_of(span)).filter((stem) => stem !== void 0);
+  return /* @__PURE__ */ new Set([...stems, ...spans.flatMap((span) => commands_of(span))]);
+}
+function commands_for(path) {
+  const registered = Object.entries(COMMAND_MAP).filter(([, entry]) => entry.script === path).map(([command]) => command);
+  if (MARKDOWN.test(path) || test_related_pins.is_registry_source(path)) return registered;
+  const source = file_reader.read_if_readable(path) ?? "";
+  const named = [...source.matchAll(COMMAND_WORD)].map((match) => match[0]);
+  return [.../* @__PURE__ */ new Set([...registered, ...named.filter((word) => is_command(word))])];
+}
+function names_of(path) {
+  return [module_of(path), ...commands_for(path)];
+}
+function references(kept_body, child_body) {
+  const kept = kept_names(kept_body);
+  const files = [...backlog_overlap.declared_paths(child_body)].filter(
+    (path) => !path.endsWith(SEPARATOR)
+  );
+  return files.map((path) => ({ path, name: names_of(path).find((candidate) => kept.has(candidate)) ?? "" })).filter((reference) => reference.name !== "");
+}
+function format_refusal(kept, found) {
+  const named = found.map(({ path, name }) => `\`${name}\` (\`${path}\`)`).join(", ");
+  return [
+    `\u2716 ${session_cite.issue(kept)}'s expected result or acceptance criteria name what this split takes off: ${named}. The kept Issue depends on the split-off part, so it cannot merge first.`,
+    `File the part as a prerequisite instead (\`--route split --label route:tier-a\`), then run \`pnpm josh run:split ${kept} --prerequisite <P>\` \u2014 \`prerequisite.md\`; nothing was filed.`
+  ].join("\n");
+}
+function kept_issue({ route, found_during }) {
+  if (route !== SPLIT_ROUTE_LABEL || found_during === void 0) return void 0;
+  return issue_number_shape.is_issue_number(found_during) ? found_during : void 0;
+}
+function is_prerequisite({ labels = [] }) {
+  return labels.includes(TIER_A_ROUTE_LABEL);
+}
+async function kept_deliverable_body(issue) {
+  const raw = await git_gh_command.issue_get_labels_and_body(issue);
+  const subject = epic_validate.parse_epic_subject(raw);
+  if (subject === void 0) return void 0;
+  const tracked = epic_parse.parse_task_list_issue_numbers(subject.body);
+  const shape = { epic_number: subject.number, labels: subject.labels, body: subject.body };
+  return epic_shape.find_subject_error(shape, tracked) === void 0 ? void 0 : subject.body;
+}
+async function refusal_of(filing, child_body) {
+  if (is_prerequisite(filing)) return void 0;
+  const found_during = kept_issue(filing);
+  if (found_during === void 0) return void 0;
+  const kept_body = await kept_deliverable_body(found_during);
+  const found = kept_body === void 0 ? [] : references(kept_body, child_body);
+  return found.length === 0 ? void 0 : format_refusal(found_during, found);
+}
+async function is_direction_clear(filing, child_body) {
+  const refusal = await refusal_of(filing, child_body);
+  if (refusal !== void 0) console.error(refusal);
+  return refusal === void 0;
+}
+var split_direction = { is_direction_clear, references, refusal_of };
+
+// scripts/issue/issue-backlinks.ts
+var ORIGIN_HEADING = "## Origin";
+var UPSTREAM_ISSUES_HEADING = "## Upstream issues";
+var UPSTREAM_CANDIDATE_HEADING = "## Upstream candidate";
+var CHECKBOX_PATTERN = /^\s*-\s*\[[ xX]\]/u;
+var WRONG_UPSTREAM_HEADING_PATTERN = /^##\s+Upstream\b/iu;
+var BARE_REFERENCE_PATTERN = /^#\d+$/u;
+var REFERENCE_MARK = "#";
+var PATH_SEPARATOR = "/";
+var PATH_SEGMENT_COUNT = 2;
+var OK = "ok";
+var WRONG_HEADING = "wrong-heading";
+var MISSING_UPSTREAM = "missing-upstream";
+function has_heading(body, heading) {
+  return markdown_section.has_line(body, heading);
+}
+function upstream_section_lines(body) {
+  if (!has_heading(body, UPSTREAM_ISSUES_HEADING)) return void 0;
+  return markdown_section.section_lines(body, UPSTREAM_ISSUES_HEADING);
+}
+function has_wrong_upstream_heading(body) {
+  return markdown_section.unfenced_lines(body).some((line) => {
+    const heading = line.trim();
+    if (heading === UPSTREAM_ISSUES_HEADING || heading === UPSTREAM_CANDIDATE_HEADING) return false;
+    return WRONG_UPSTREAM_HEADING_PATTERN.test(heading);
+  });
+}
+function tokens_of(section) {
+  return section.join(" ").split(/\s+/u).filter((token) => token.length > 0);
+}
+function has_two_segments(path = "") {
+  const segments = path.split(PATH_SEPARATOR);
+  return segments.length === PATH_SEGMENT_COUNT && segments.every((segment) => segment.length > 0);
+}
+function is_qualified_reference(token) {
+  const [path, number, ...rest] = token.split(REFERENCE_MARK);
+  if (number === void 0 || rest.length > 0) return false;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(number) && has_two_segments(path);
+}
+function has_bare_reference(section) {
+  return tokens_of(section).some((token) => BARE_REFERENCE_PATTERN.test(token));
+}
+function has_checkbox_reference(section) {
+  return section.some((line) => CHECKBOX_PATTERN.test(line) && line.includes(REFERENCE_MARK));
+}
+function is_malformed_upstream_section(section) {
+  return has_bare_reference(section) || has_checkbox_reference(section);
+}
+function every_upstream_cites_origin(upstreams) {
+  return upstreams.every((upstream) => has_heading(upstream.body, ORIGIN_HEADING));
+}
+function verdict_without_section(origin_body) {
+  return has_heading(origin_body, UPSTREAM_CANDIDATE_HEADING) ? OK : MISSING_UPSTREAM;
+}
+function verdict_with_section(section, upstreams) {
+  if (is_malformed_upstream_section(section)) return WRONG_HEADING;
+  if (upstreams.length === 0) return MISSING_UPSTREAM;
+  return every_upstream_cites_origin(upstreams) ? OK : "missing-origin";
+}
+function classify_backlinks(origin_body, upstreams) {
+  if (has_wrong_upstream_heading(origin_body)) return WRONG_HEADING;
+  const section = upstream_section_lines(origin_body);
+  return section === void 0 ? verdict_without_section(origin_body) : verdict_with_section(section, upstreams);
+}
+function upstream_references(origin_body) {
+  const section = upstream_section_lines(origin_body);
+  if (section === void 0) return [];
+  return tokens_of(section).filter((token) => is_qualified_reference(token));
+}
+function needs_upstreams(origin_body) {
+  if (has_wrong_upstream_heading(origin_body)) return false;
+  const section = upstream_section_lines(origin_body);
+  if (section === void 0) return false;
+  return !is_malformed_upstream_section(section);
+}
+var issue_backlinks = {
+  classify_backlinks,
+  upstream_refs: upstream_references,
+  needs_upstreams,
+  ORIGIN_HEADING,
+  UPSTREAM_ISSUES_HEADING,
+  UPSTREAM_CANDIDATE_HEADING
+};
+
+// scripts/issue/issue-file.ts
+var ROUTE_PREFIX = "route:";
+var LIST_SEPARATOR = ",";
+var WORD_SEPARATOR = /\s+/u;
+var CODE_SPAN2 = /`/gu;
+var LEADING_NON_WORD = /^[^\w]+/u;
+var DIGIT = /\d/u;
+var OPTIONS = {
+  ...backlog_triage_decision.OPTIONS,
+  "body-file": { type: "string" },
+  route: { type: "string" },
+  label: { type: "string", multiple: true },
+  repo: { type: "string" },
+  distinct: { type: "string", multiple: true },
+  "found-during": { type: "string" },
+  "over-cap": { type: "boolean" },
+  "no-auto-ok": { type: "boolean" },
+  release: { type: "boolean" },
+  "blocks-finder": { type: "boolean" },
+  check: { type: "boolean" }
+};
+function label_of(prefix, value, known) {
+  if (value === void 0) return void 0;
+  const label = value.startsWith(prefix) ? value : `${prefix}${value}`;
+  return known.includes(label) ? label : void 0;
+}
+var ROUTE_NAMES = FILING_ROUTE_LABELS.map((label) => label.name);
+function distinct_numbers(values) {
+  const numbers = values.flatMap((value) => value.split(LIST_SEPARATOR)).map((raw) => {
+    return Number(raw.trim().replace("#", ""));
+  });
+  return numbers.every((number) => Number.isSafeInteger(number) && number > 0) ? numbers : void 0;
+}
+function route_of(values) {
+  if (values.route === void 0) return void 0;
+  return label_of(ROUTE_PREFIX, values.route, ROUTE_NAMES) ?? false;
+}
+function has_text(value) {
+  return value !== void 0 && value.trim() !== "";
+}
+function found_during_of(value) {
+  if (value === void 0) return void 0;
+  const numbers = distinct_numbers([value]);
+  return numbers?.length === 1 ? String(numbers[0]) : false;
+}
+function labelled_of(values) {
+  const route = route_of(values);
+  const distinct = distinct_numbers(values.distinct ?? []);
+  const found_during = found_during_of(values["found-during"]);
+  if (route === false || distinct === void 0 || found_during === false) return void 0;
+  return { route, distinct, found_during };
+}
+function arguments_of(values, title) {
+  const labelled = labelled_of(values);
+  const body_file = values["body-file"];
+  if (labelled === void 0 || !has_text(title) || !has_text(body_file)) return void 0;
+  return {
+    title,
+    body_file,
+    answers: {
+      defect: values.defect,
+      verification: values.verification,
+      "every-run": values["every-run"]
+    },
+    ...labelled,
+    labels: values.label ?? [],
+    repo: values.repo,
+    is_over_cap: values["over-cap"] === true,
+    is_auto_ok_opted_out: values["no-auto-ok"] === true,
+    is_release: values.release === true,
+    is_blocking_finder: values["blocks-finder"] === true,
+    is_check: values.check === true
+  };
+}
+function parse(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  const args = parsed === void 0 ? void 0 : arguments_of(parsed.values, parsed.positionals[0]);
+  if (args === void 0 || !has_label_name(args.labels, RUN_SOLO_LABEL)) return args;
+  return issue_run_verdict.run_label_of({ ...args.answers, solo: true }) === RUN_SOLO_LABEL ? args : void 0;
+}
+function is_undeclared_classification(label, body) {
+  const is_classification = has_label_name(issue_classification.CLASSIFICATION_LABELS, label);
+  return is_classification && !has_label_name(issue_classification.required_labels(body), label);
+}
+function labels_of(args, body, is_auto_ok = false) {
+  const extra = args.labels.filter((label) => !is_undeclared_classification(label, body));
+  const declared = [...args.route === void 0 ? [] : [args.route], ...extra];
+  const labels = issue_priority.with_label(
+    issue_not_before_label.with_label(issue_classification.labels_for(body, declared), body),
+    body
+  );
+  if (!is_auto_ok || has_label_name(labels, AUTO_OK_LABEL)) return labels;
+  return [...labels, AUTO_OK_LABEL];
+}
+function triage_problem(labels) {
+  const is_owed = has_label_name(labels, AUTO_OK_LABEL) && !epic_triage.has_triage_label(labels);
+  if (!is_owed) return void 0;
+  return `an \`${AUTO_OK_LABEL}\` filing needs \`--label ${RUN_LANE_LABEL}\` or \`--label ${RUN_SOLO_LABEL}\` \u2014 \`${RUN_SOLO_LABEL}\` only for a defect in kit's own verification that makes unrelated PRs answer wrongly on main on every run (\`backlogrun-lanes.md\`), else \`${RUN_LANE_LABEL}\` \u2014 a flaky one takes \`${RUN_LANE_LABEL}\` and \`priority:critical\``;
+}
+function is_same_repository(target, current) {
+  return target.toLowerCase() === current.toLowerCase();
+}
+function without_trailing_prose(text) {
+  let end = text.length;
+  while (end > 0 && !DIGIT.test(text.charAt(end - 1))) end -= 1;
+  return text.slice(0, end);
+}
+function is_qualified_reference2(word) {
+  const bare = without_trailing_prose(word.replaceAll(CODE_SPAN2, "").replace(LEADING_NON_WORD, ""));
+  return epic_issue.parse_epic_reference(bare)?.repo !== void 0 || github_issue_url.parse(bare) !== void 0;
+}
+function cites_origin(line) {
+  return line.split(WORD_SEPARATOR).some((word) => is_qualified_reference2(word));
+}
+function origin_problem(body, target, current) {
+  if (is_same_repository(target, current)) return void 0;
+  const lines = markdown_section.section_lines(body, issue_backlinks.ORIGIN_HEADING);
+  if (lines.some((line) => cites_origin(line))) return void 0;
+  return `filing into ${target} from ${current} needs a \`${issue_backlinks.ORIGIN_HEADING}\` section citing the originating Issue as \`owner/repo#N\` or its URL`;
+}
+function unacknowledged(candidates, distinct) {
+  return candidates.filter((candidate) => !distinct.includes(candidate));
+}
+function acknowledged(args, target, current) {
+  if (args.found_during === void 0 || !is_same_repository(target, current)) return args.distinct;
+  return [...args.distinct, Number(args.found_during)];
+}
+var issue_file = {
+  parse,
+  labels_of,
+  origin_problem,
+  triage_problem,
+  unacknowledged,
+  acknowledged,
+  is_same_repository
+};
+
+// scripts/issue/issue-file-fold.ts
+var REFERENCE_NUMBER = /#(?<number>\d+)$/u;
+var CLOSED_STATE = "CLOSED";
+function number_of(reference) {
+  return Number(REFERENCE_NUMBER.exec(reference)?.groups?.["number"]);
+}
+function reference_prefix(target, current) {
+  return issue_file.is_same_repository(target, current) ? "" : target;
+}
+function prefix_of(reference) {
+  return reference.slice(0, reference.lastIndexOf("#"));
+}
+async function branch_issue() {
+  try {
+    return git_branch.issue_from_branch(await git_command.branch());
+  } catch {
+    return void 0;
+  }
+}
+async function finder(named) {
+  if (named !== void 0) return named;
+  const marked = lane_child_marker.marked_issue();
+  if (marked !== void 0) return marked;
+  const issue = await branch_issue();
+  return issue === void 0 ? void 0 : String(issue);
+}
+async function events_of(found_during) {
+  if (found_during === void 0) return await run_event_stream_emit.current_events();
+  return await run_event_stream_emit.all_events();
+}
+function finder_filings(events, found_during) {
+  return events.filter((event) => event.kind === run_event_stream.EVENT_KIND.FILED).flatMap((event) => run_event_filed.parse(event.text) ?? []).filter((filed) => filed.found_during === found_during);
+}
+function prior_filings(events, found_during, prefix, distinct) {
+  return finder_filings(events, found_during).filter((filed) => prefix_of(filed.reference) === prefix).filter((filed) => !distinct.includes(number_of(filed.reference)));
+}
+async function is_open(filed, prefix) {
+  const repo = prefix === "" ? void 0 : prefix;
+  const read = await issue_state_cli.read_issue(String(number_of(filed.reference)), repo);
+  return read.kind !== "state" || read.state.state !== CLOSED_STATE;
+}
+async function open_filings(priors, prefix) {
+  const verdicts = await Promise.all(priors.map(async (filed) => await is_open(filed, prefix)));
+  return priors.filter((_filed, index) => verdicts[index]);
+}
+function references_of(priors) {
+  return priors.map((filed) => filed.reference).join(", ");
+}
+function line_of(verdict, priors) {
+  return `fold: ${issue_fold_cli.REASONS[verdict]} \xB7 filed earlier by this finder: ${references_of(priors)}`;
+}
+function held_message(priors) {
+  const listed = priors.map((filed) => String(number_of(filed.reference))).join(",");
+  return `\u2716 fold: add this finding to ${references_of(priors)} (its body or a comment) rather than filing it; a finding that is really a separate deliverable reissues with \`--distinct ${listed}\` (\`split-assessment.md\` \u2192 "The question").`;
+}
+async function is_fold_clear(prefix, args) {
+  if (args.route === SPLIT_ROUTE_LABEL) return true;
+  const found_during = await finder(args.found_during);
+  const filings = prior_filings(await events_of(found_during), found_during, prefix, args.distinct);
+  const priors = await open_filings(filings, prefix);
+  if (priors.length === 0) return true;
+  const size = await issue_fold_cli.size_verdict();
+  const verdict = issue_fold.fold_verdict(priors.length + 1, true, size);
+  console.info(line_of(verdict, priors));
+  if (verdict === issue_fold.FOLD) console.error(held_message(priors));
+  return verdict !== issue_fold.FOLD;
+}
+var issue_file_fold = {
+  events_of,
+  finder,
+  finder_filings,
+  is_fold_clear,
+  prior_filings,
+  reference_prefix
+};
+
+// scripts/issue/issue-file-cap.ts
+var FILING_CAP = 10;
+async function prior_count(origin) {
+  const events = await issue_file_fold.events_of(origin);
+  return issue_file_fold.finder_filings(events, origin).filter((filed) => filed.is_run === true).length;
+}
+function owner_of(origin) {
+  return origin === void 0 ? "this run (no originating Issue)" : session_cite.issue(origin);
+}
+function reason_of(origin) {
+  return `\u2716 filing cap: ${owner_of(origin)} has already filed ${String(FILING_CAP)} Issues, the ceiling per originating work item. Stop filing and report; a further Issue is a person's to file from their own session (\`.claude/skills/workflow-commands/prerequisite.md\`).`;
+}
+async function is_cap_clear(named) {
+  if (!await run_hold_member.is_run_member()) return true;
+  const origin = await issue_file_fold.finder(named);
+  if (await prior_count(origin) < FILING_CAP) return true;
+  console.error(reason_of(origin));
+  return false;
+}
+var issue_file_cap = { FILING_CAP, is_cap_clear, reason_of };
+
+// scripts/issue/issue-file-deferral.ts
+var NOTE_PREFIX = "\u5148\u9001\u308A:";
+function note_of(deferral) {
+  return `${NOTE_PREFIX} ${deferral.reference} ${deferral.title}`;
+}
+function failure_line(finder2, note) {
+  const rerun = `pnpm josh issue:comment ${String(finder2)} --body ${shell_quote.single_quoted(note)}`;
+  return `\u26A0 the deferral note did not reach ${session_cite.issue(finder2)} \u2014 run \`${rerun}\`.`;
+}
+async function note_finder(deferral) {
+  const finder2 = Number(deferral.found_during);
+  if (!Number.isSafeInteger(finder2) || finder2 <= 0) return;
+  const note = note_of(deferral);
+  const is_noted = await git_gh_issue_write.issue_try_comment(
+    String(finder2),
+    note,
+    deferral.current
+  );
+  if (!is_noted) console.error(failure_line(finder2, note));
+}
+var issue_file_deferral = { NOTE_PREFIX, note_finder };
+
+// scripts/issue/issue-file-interrupt.ts
+var DECISION_PREFIX = "\u6C7A\u5B9A:";
+var CONVERTED_NOTE = "\u306E\u7740\u5730\u5F85\u3061\uFF08\u4F9D\u5B58\u306B\u5909\u63DB\uFF09";
+function is_issue_number(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+function finder_of(filing) {
+  if (filing.route !== INTERRUPT_ROUTE_LABEL || !filing.is_here) return void 0;
+  const finder2 = Number(filing.found_during);
+  return is_issue_number(finder2) ? finder2 : void 0;
+}
+function ignored_line(filing) {
+  const reason = filing.route === INTERRUPT_ROUTE_LABEL ? "no finder and filed Issue pair in this repository was read" : "it applies to `--route interrupt` only";
+  return `\u26A0 --blocks-finder recorded nothing: ${reason}.`;
+}
+function failure_line2(blocked, blocker) {
+  const path = git_gh_api_path.blocked_by_api_path(String(blocked));
+  const id = `$(gh api ${git_gh_api_path.issue_api_path(String(blocker))} --jq .id)`;
+  const cited = `${session_cite.issue(blocked)} could not be recorded as blocked by ${session_cite.issue(blocker)}`;
+  return `\u26A0 ${cited} \u2014 run \`gh api ${path} -F issue_id=${id}\`.`;
+}
+async function record(pair) {
+  const links = [pair];
+  const failures = await epic_relations.apply_relations(links, "record");
+  if (failures === 0) {
+    console.info(epic_relations.format_relation_report({ links, failures, action: "record" }));
+    return true;
+  }
+  console.error(failure_line2(pair.blocked, pair.blocker));
+  return false;
+}
+function pair_of(filing) {
+  const blocked = finder_of(filing);
+  return blocked !== void 0 && is_issue_number(filing.blocker) ? { blocked, blocker: filing.blocker } : void 0;
+}
+async function is_parked(pair) {
+  if (pair === void 0) return false;
+  const names = await git_gh_issue_write.read_label_names(String(pair.blocked));
+  return names?.includes(NEEDS_DECISION_LABEL) === true;
+}
+function kept_line(finder2, decision) {
+  return `\u26A0 ${session_cite.issue(finder2)} kept ${NEEDS_DECISION_LABEL} \u2014 post "${decision}" if it is missing, then run \`pnpm josh run:park ${finder2} --clear\`.`;
+}
+async function convert_park(pair) {
+  const finder2 = String(pair.blocked);
+  const decision = `${DECISION_PREFIX} ${issue_cite.plain_for("github", pair.blocker)} ${CONVERTED_NOTE}`;
+  const is_cleared = await git_gh_issue_write.issue_try_comment(finder2, decision) && await git_gh_issue_write.issue_clear_label(finder2, NEEDS_DECISION_LABEL);
+  if (!is_cleared) console.error(kept_line(finder2, decision));
+}
+async function block_pair(filing, pair, is_converting) {
+  if (pair === void 0) {
+    console.warn(ignored_line(filing));
+    return;
+  }
+  const is_recorded = await record(pair);
+  if (is_converting && is_recorded) await convert_park(pair);
+}
+async function block_finder(filing) {
+  const pair = pair_of(filing);
+  const is_converting = await is_parked(pair);
+  if (!is_converting && !filing.is_blocking_finder) return;
+  await block_pair(filing, pair, is_converting);
+}
+var issue_file_interrupt = { block_finder };
+
+// scripts/issue/issue-file-lane-hint.ts
+async function lines_of(found_during, body) {
+  if (found_during === void 0 || issue_priority.lane_minutes(body) > 0) return [];
+  const minutes = await lane_net_read.net_minutes_of(Number(found_during));
+  if (minutes === void 0) return [];
+  const line = `${issue_priority.LANE_PREFIX} ${String(minutes)} \u5206\uFF08${issue_cite.plain_for("github", found_during)}\uFF09`;
+  return [
+    `\u21B3 the causing lane from \`josh lane:net ${found_during}\`, to paste under \`${issue_body_keys.heading("background")}\` when it caused this Issue:`,
+    line
+  ];
+}
+var issue_file_lane_hint = {
+  lines_of
+};
+
+// scripts/issue/issue-file-worker.ts
+var { LABEL_PREFIX } = agent_worker_profile;
+var LABEL_COLOR = "bfd4f2";
+var LABEL_DESCRIPTION = "Lane worker profile (josh.worker)";
+function settings_of(place2) {
+  if (!issue_file.is_same_repository(place2.target, place2.current)) return void 0;
+  return agent_worker_profile.read(process.cwd());
+}
+function worker_labels(labels) {
+  return [...new Set(labels.filter((label) => label.startsWith(LABEL_PREFIX)))];
+}
+function guide_of(settings) {
+  const rows = settings.profiles.map(
+    (profile) => `  ${LABEL_PREFIX}${profile.name} \u2014 ${profile.when}`
+  );
+  return [
+    `worker profiles (josh.worker, weakest first) \u2014 choose one with --label ${LABEL_PREFIX}<name>; none \u2192 ${settings.default}:`,
+    ...rows
+  ].join("\n");
+}
+function is_unchecked_clear(note, labels) {
+  if (worker_labels(labels).length === 0) {
+    console.warn(`\u26A0 ${note}`);
+    return true;
+  }
+  console.error(`\u2716 ${note}`);
+  return false;
+}
+function is_choice_clear(settings, labels) {
+  console.info(guide_of(settings));
+  const chosen = agent_worker_profile.for_labels(settings, worker_labels(labels));
+  if (chosen.kind === "worker") return true;
+  console.error(`\u2716 ${chosen.kind === "rejected" ? chosen.note : chosen.kind}`);
+  return false;
+}
+function is_worker_clear(place2, labels) {
+  const result = settings_of(place2);
+  if (result === void 0 || result.kind === "unset") return true;
+  if (result.kind === "rejected") return is_unchecked_clear(result.note, labels);
+  return is_choice_clear(result.settings, labels);
+}
+function label_definitions(place2, labels) {
+  if (settings_of(place2)?.kind !== "settings") return [];
+  return worker_labels(labels).map((name) => ({
+    name,
+    color: LABEL_COLOR,
+    description: LABEL_DESCRIPTION
+  }));
+}
+var issue_file_worker = { is_worker_clear, label_definitions };
+
+// scripts/issue/issue-sample-required.ts
+var AFTER_CITED_CHANGE = [
+  /#[1-9]\d*(?:\s*|[^#\n]{0,16}?(?:の|マージ(?:した|直)?))後(?![述始片続])/u,
+  /#[1-9]\d*[^#\n]{0,16}?(?:以降|以後)/u
+];
+var RECORD_READERS = ["lane:stats", "actions/runs", "ship --log"];
+var LEDGER_READ = /lane:breakdown(?:[^`\n]*`)?\s*(?:の(?:出力|結果|表))?で(?![きすは])/u;
+var CLOSING_NOTE = /（[^（）]*）\s*$/u;
+var TEST_VERIFIED = "\u30C6\u30B9\u30C8";
+var CITATION_PATTERN = /#[1-9]\d*/u;
+var BACKGROUND_HEADING = issue_body_keys.heading("background");
+var MISSING = `measurement follow-up without its start condition: declare \`${issue_sample_gate.DECLARATION}\`, or \`${issue_sample_gate.CLOSING_FORMAT}\` before that pull request exists, under ${BACKGROUND_HEADING} \u2014 prompts/collaboration-workflow/measurement.md \u2192 "\u52B9\u679C\u3092\u6E2C\u308B\u5F8C\u7D9A Issue"`;
+var UNDECLARED = `measurement follow-up without a measure declaration: declare \`${measure_declaration.DECLARATION}\` (any \`lane:stats\` cell: \`pnpm josh lane:value cell\`), or \`${measure_declaration.ABSENT}\` when no one command prints the value, under ${BACKGROUND_HEADING} \u2014 prompts/collaboration-workflow/measurement.md \u2192 "\u52B9\u679C\u3092\u6E2C\u308B\u5F8C\u7D9A Issue"
+${measure_declaration.EXAMPLE}`;
+function measures_a_change(criterion) {
+  if (AFTER_CITED_CHANGE.some((pattern) => pattern.test(criterion))) return true;
+  return CITATION_PATTERN.test(criterion) && RECORD_READERS.some((reader) => criterion.includes(reader));
+}
+function reads_the_ledger(criterion) {
+  const note = CLOSING_NOTE.exec(criterion)?.[0] ?? "";
+  return LEDGER_READ.test(criterion) && !note.includes(TEST_VERIFIED);
+}
+function is_measurement(body) {
+  if (measure_declaration.parse(body) !== void 0) return true;
+  const criteria = acceptance_map.criteria_of(body);
+  if (criteria.some((criterion) => reads_the_ledger(criterion.text))) return true;
+  if (size_estimate.declared_files(body) !== 0) return false;
+  return criteria.some((criterion) => measures_a_change(criterion.text));
+}
+function problem(body) {
+  if (issue_sample_gate.cited_number(body) !== void 0) {
+    return measure_declaration.is_stated(body) ? void 0 : UNDECLARED;
+  }
+  return is_measurement(body) ? MISSING : void 0;
+}
+var issue_sample_required = { problem };
+
+// scripts/issue/issue-sample-source.ts
+async function read_is_pull(number, repo) {
+  try {
+    const json = await git_gh_exec.exec_gh_api({
+      path: git_gh_api_path.issue_api_path(String(number), repo)
+    });
+    return git_gh_issue_rest.is_pull_request(git_gh_issue_rest.parse_rest_issue(json));
+  } catch {
+    return void 0;
+  }
+}
+async function read_closing_number(issue) {
+  return await issue_closing_pr.read_closing_number(issue);
+}
+var DEFAULT_PORTS = { is_pull: read_is_pull, closing_pr: read_closing_number };
+async function hint_of(issue, repo, ports) {
+  const closing = repo === void 0 ? await ports.closing_pr(issue) : void 0;
+  if (closing === void 0) {
+    return `cite the pull request whose merge it waits on, or write \`${issue_sample_gate.CLOSING_FORMAT}\` to wait on the one that closes it`;
+  }
+  return `cite the pull request that closed it: ${session_cite.issue(closing)}`;
+}
+async function problem2(body, repo, ports = DEFAULT_PORTS) {
+  const number = issue_sample_gate.cited_via(body, "pull");
+  if (number === void 0 || await ports.is_pull(number, repo) !== false) return void 0;
+  const cited = session_cite.issue(number, void 0, repo);
+  const hint = await hint_of(number, repo, ports);
+  return `\`${issue_body_keys.prefix("sample_gate")}\` cites ${cited}, an issue, not a pull request \u2014 ${hint}`;
+}
+var issue_sample_source = { problem: problem2 };
+
+// scripts/issue/issue-wip.ts
+var DEFAULT_WIP_CAP = 30;
+var WIP_CAP_KEY = "JOSH_WIP_CAP";
+var CAP_OFF = "off";
+var WITHIN = "within";
+var EXEMPT = "exempt";
+var HELD = "held";
+var EXEMPT_ROUTES = /* @__PURE__ */ new Set([
+  TIER_A_ROUTE_LABEL,
+  SPLIT_ROUTE_LABEL,
+  INTERRUPT_ROUTE_LABEL
+]);
+var HELD_MESSAGE = "\u2716 over the WIP cap: close one first; nothing honestly closable means do not file \u2014 a discretionary filing waits. An interrupt meeting one of three tests (a verification answers wrongly, a documented workflow cannot complete, or data is lost or written outside the repository) files with `--route interrupt`; a filing the run is blocked by reissues with `--over-cap`. Either way, state the overage (`prompts/collaboration-workflow/wip-cap.md`).";
+var UNREAD_MESSAGE = "\u26A0 wip: could not count the open Issues \u2014 the filing goes on unchecked against the cap (`prompts/collaboration-workflow/wip-cap.md`).";
+function read_cap(environment = process.env) {
+  const raw = environment[WIP_CAP_KEY];
+  if (raw?.trim().toLowerCase() === CAP_OFF) return { kind: "cap", cap: CAP_OFF };
+  const setting = cli_flags.read_positive_setting(raw, WIP_CAP_KEY, DEFAULT_WIP_CAP);
+  if (setting.kind === "problem") {
+    return { kind: "problem", problem: `${setting.problem} (or "${CAP_OFF}" to turn the cap off)` };
+  }
+  return { kind: "cap", cap: setting.limit };
+}
+function is_exempt(filing) {
+  return filing.is_over_cap || filing.route !== void 0 && EXEMPT_ROUTES.has(filing.route);
+}
+function verdict_of(count, filing, cap) {
+  if (cap === CAP_OFF || count <= cap) return WITHIN;
+  return is_exempt(filing) ? EXEMPT : HELD;
+}
+function count_line(count, repo, verdict, cap) {
+  return `wip: ${String(count)} open in ${repo} \xB7 cap ${String(cap)} \xB7 ${verdict}`;
+}
+function count_of(json) {
+  return json_value.parse_array(json)?.length;
+}
+var issue_wip = {
+  DEFAULT_WIP_CAP,
+  WIP_CAP_KEY,
+  CAP_OFF,
+  HELD,
+  HELD_MESSAGE,
+  UNREAD_MESSAGE,
+  read_cap,
+  verdict_of,
+  count_line,
+  count_of
+};
+
+// scripts/issue/issue-file-pass.ts
+var GH_REPO_VARIABLE = "GH_REPO";
+function auto_ok_filing(filing) {
+  return {
+    is_opted_out: filing.args.is_auto_ok_opted_out,
+    is_cross_repository: !issue_file.is_same_repository(filing.target, filing.current),
+    labels: issue_file.labels_of(filing.args, filing.body),
+    body: filing.body
+  };
+}
+function refusals_of(filing, rate, growth) {
+  const problems = [
+    ...issue_lint_cli.problems(filing.body, issue_file.labels_of(filing.args, filing.body)),
+    size_estimate.guide_problem(filing.body, filing.args.route, rate, growth),
+    issue_sample_required.problem(filing.body),
+    issue_auto_ok.declaration_problem(filing.body),
+    issue_auto_ok.opt_out_problem(auto_ok_filing(filing)),
+    issue_priority.problem(filing.body, filing.args.labels),
+    issue_file.origin_problem(filing.body, filing.target, filing.current)
+  ];
+  return problems.filter((problem3) => problem3 !== void 0).map((problem3) => `\u2716 ${problem3}`);
+}
+function unacknowledged_message(open, declared) {
+  const listed = open.map(String).join(",");
+  const pasted = [.../* @__PURE__ */ new Set([...declared, ...open])].map(String).join(",");
+  return `\u2716 duplicate candidate(s) ${listed} not declared separate \u2014 read each (\`issue-fold-existing.md\`); fold into a duplicate, or reissue with \`--distinct ${pasted}\` when each is a separate deliverable.`;
+}
+async function open_count(target) {
+  const outcome = await git_gh_issue_list.issue_list({
+    json_fields: "number",
+    limit: MAX_SCANNED,
+    repo: target
+  });
+  return outcome.json === void 0 ? void 0 : issue_wip.count_of(outcome.json);
+}
+async function is_count_clear(filing, cap) {
+  const count = await open_count(filing.target);
+  if (count === void 0) {
+    console.error(issue_wip.UNREAD_MESSAGE);
+    return true;
+  }
+  const verdict = issue_wip.verdict_of(count, filing.args, cap);
+  console.info(issue_wip.count_line(count, filing.target, verdict, cap));
+  if (verdict === issue_wip.HELD) console.error(issue_wip.HELD_MESSAGE);
+  return verdict !== issue_wip.HELD;
+}
+async function is_wip_clear(filing) {
+  const setting = issue_wip.read_cap();
+  if (setting.kind === "problem") {
+    console.error(`\u2716 ${setting.problem}`);
+    return false;
+  }
+  return await is_count_clear(filing, setting.cap);
+}
+function point_listings_at(filing) {
+  if (issue_file.is_same_repository(filing.target, filing.current)) return;
+  process.env[GH_REPO_VARIABLE] = filing.target;
+}
+async function scout_filing(filing) {
+  point_listings_at(filing);
+  return await issue_scout_cli.scout({ title: filing.args.title, body: filing.body }, filing.target);
+}
+function is_measure_clear(outcome) {
+  const problem3 = measure_twin.problem(outcome.measure_twins ?? []);
+  if (problem3 === void 0) return true;
+  console.error(`\u2716 ${problem3}`);
+  return false;
+}
+function is_candidate_clear(filing, outcome) {
+  const answered = issue_file.acknowledged(filing.args, filing.target, filing.current);
+  const open = issue_file.unacknowledged(outcome.candidates, answered);
+  if (open.length > 0) console.error(unacknowledged_message(open, filing.args.distinct));
+  return open.length === 0;
+}
+async function is_scout_clear(filing) {
+  const outcome = filing.scouted ?? await scout_filing(filing);
+  if (outcome === void 0) return false;
+  if (filing.scouted === void 0) console.info(outcome.report);
+  point_listings_at(filing);
+  const verdicts = [is_candidate_clear(filing, outcome), is_measure_clear(outcome)];
+  return verdicts.every(Boolean);
+}
+function labels_of2(filing) {
+  const auto_ok = issue_auto_ok.decide(auto_ok_filing(filing));
+  console.info(issue_auto_ok.line_of(auto_ok));
+  const labels = issue_file.labels_of(filing.args, filing.body, auto_ok.is_applied);
+  const problem3 = issue_file.triage_problem(labels);
+  if (problem3 === void 0) return labels;
+  console.error(`\u2716 ${problem3}`);
+  return void 0;
+}
+async function cap_refusals(filing) {
+  if (!issue_file.is_same_repository(filing.target, filing.current)) return [];
+  const problem3 = issue_cap_files.problem(
+    await issue_cap_files.near_cap(filing.body, process.cwd())
+  );
+  return problem3 === void 0 ? [] : [`\u2716 ${problem3}`];
+}
+async function is_admitted(filing) {
+  const { implement_rate, growth } = await lane_net_read.measurements();
+  const capped = await cap_refusals(filing);
+  const refusals = [...refusals_of(filing, implement_rate, growth), ...capped];
+  issue_lint_cli.warn(filing.body);
+  if (refusals.length === 0) return true;
+  const hint = await issue_file_lane_hint.lines_of(filing.args.found_during, filing.body);
+  console.error([...refusals, ...hint].join("\n"));
+  return false;
+}
+async function is_source_clear(filing) {
+  const is_here = issue_file.is_same_repository(filing.target, filing.current);
+  const problem3 = await issue_sample_source.problem(
+    filing.body,
+    is_here ? void 0 : filing.target
+  );
+  if (problem3 === void 0) return true;
+  console.error(`\u2716 ${problem3}`);
+  return false;
+}
+async function labels_in_one_pass(filing) {
+  const is_body_clear = await is_admitted(filing);
+  const labels = labels_of2(filing);
+  const verdicts = [
+    is_body_clear,
+    labels !== void 0,
+    issue_file_worker.is_worker_clear(filing, labels ?? filing.args.labels),
+    await is_source_clear(filing),
+    await is_wip_clear(filing),
+    await is_scout_clear(filing)
+  ];
+  return verdicts.every(Boolean) ? labels : void 0;
+}
+var issue_file_pass = {
+  GH_REPO_VARIABLE,
+  labels_in_one_pass,
+  scout_filing
+};
+
+// scripts/issue/issue-file-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var USAGE = 'Usage: josh issue:file "<title>" --body-file <path> [--route <tier-a|split|interrupt|review-cap>] [--label <name>]\u2026 [--defect yes|no|unknown] [--verification yes|no|unknown] [--every-run yes|no|unknown] [--repo <owner/repo>] [--distinct <N,\u2026>] [--found-during <N>] [--over-cap] [--no-auto-ok] [--release] [--blocks-finder] [--check]';
+var CHECK_CLEAR_MESSAGE = "check: every filing step passed \u2014 nothing filed (`--check`).";
+var UNKNOWN_REPO_MESSAGE = "Could not read this repository from `git remote`, so the filing has no repository to compare against \u2014 check `gh auth status`.";
+var THIRD_PARTY_MESSAGE = '\u2716 third-party target: a tracker we do not own is Tier C \u2014 draft the Issue for a person to post instead (`CLAUDE.md` \u2192 "Third-party repositories are Tier C").';
+var UNKNOWN_PARTY_MESSAGE = "\u2716 unknown party: the owner of this session or of the target could not be read (`git remote` / `--repo`), so the target is not known to be ours \u2014 check `pnpm josh repo:party`.";
+var { GH_REPO_VARIABLE: GH_REPO_VARIABLE2 } = issue_file_pass;
+function party_refusal(target) {
+  const party = repo_party.classify(repo_party.current_owner(), repo_party.target_owner(target));
+  if (party === repo_party.FIRST_PARTY) return void 0;
+  return party === repo_party.THIRD_PARTY ? THIRD_PARTY_MESSAGE : UNKNOWN_PARTY_MESSAGE;
+}
+async function create(filing, labels) {
+  repository_labels.ensure_labels(
+    filing.target,
+    issue_file_worker.label_definitions(filing, labels)
+  );
+  const request = git_gh_issue_write.issue_create_request({
+    title: filing.args.title,
+    body: filing.body,
+    labels,
+    repo: filing.target
+  });
+  try {
+    return await git_gh_exec.exec_gh_api(request);
+  } catch (error) {
+    const reason = error_text.message_of(error);
+    console.error(`\u2716 the create call failed: ${reason}`);
+    return void 0;
+  }
+}
+function issue_number_of(url) {
+  return Number(github_issue_url.parse(url)?.issue_number);
+}
+async function link_release(url, filing) {
+  if (!filing.args.is_release) return;
+  const issue_number = issue_number_of(url);
+  const is_linked = Number.isSafeInteger(issue_number) && await issue_release_cli.link(issue_number, filing.target);
+  if (is_linked) return;
+  console.error(
+    `\u26A0 the release link did not complete for ${url} \u2014 run \`${GH_REPO_VARIABLE2}=${filing.target} pnpm josh issue:release <N>\`.`
+  );
+}
+async function place(url, target) {
+  const issue_number = issue_number_of(url);
+  const exit_code = Number.isSafeInteger(issue_number) ? await epic_bundle_cli.report_for(issue_number, target) : FAILURE_EXIT_CODE;
+  if (exit_code !== SUCCESS_EXIT_CODE) {
+    console.error(`\u26A0 epic:bundle did not answer for ${url} \u2014 run \`pnpm josh epic:bundle <N>\`.`);
+  }
+}
+async function emit_filed(reference, filing, labels, found_during) {
+  const kind = run_event_filed.kind_of(labels);
+  const is_run = await run_hold_member.is_run_member();
+  const is_overrun = lane_child_marker.is_overrun();
+  const { title } = filing.args;
+  const text = run_event_filed.text_of({ reference, kind, title, found_during, is_run, is_overrun });
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.FILED, text);
+}
+async function record_park(issue, prerequisite) {
+  try {
+    const read = await issue_state_cli.read_issue(issue);
+    if (read.kind !== "state") throw new Error(`could not read park state: ${read.kind}`);
+    if (read.state.state !== "OPEN" || !has_parked_label(read.state.labels)) return;
+    const result = await epic_blocked_by.record({ issue, prerequisite, is_relation_only: true });
+    console.info(
+      `caused park ${session_cite.issue(issue)} blocked by ${session_cite.issue(prerequisite)}: ${result}`
+    );
+  } catch (error) {
+    console.error(
+      `\u26A0 ${session_cite.issue(prerequisite)} is already filed; caused park ${session_cite.issue(issue)} dependency could not be recorded: ${error_text.message_of(error)}`
+    );
+  }
+}
+async function record_parks(url, filing) {
+  if (!issue_file.is_same_repository(filing.target, filing.current)) return;
+  const blocker = issue_number_of(url);
+  if (!Number.isSafeInteger(blocker) || blocker <= 0) return;
+  for (const issue of issue_priority.parked_issues(filing.body)) {
+    await record_park(issue, String(blocker));
+  }
+}
+async function record2(url, filing, labels) {
+  const number = String(issue_number_of(url));
+  const reference = issue_cite.plain_for(
+    "terminal",
+    number,
+    issue_file_fold.reference_prefix(filing.target, filing.current)
+  );
+  const found_during = await issue_file_fold.finder(filing.args.found_during);
+  await emit_filed(reference, filing, labels, found_during);
+  await issue_file_deferral.note_finder({
+    found_during: filing.args.found_during,
+    reference,
+    title: filing.args.title,
+    current: filing.current
+  });
+  await split_resolution.record_child({ route: filing.args.route, found_during, child: url });
+  await issue_file_interrupt.block_finder({
+    route: filing.args.route,
+    is_blocking_finder: filing.args.is_blocking_finder,
+    found_during,
+    blocker: issue_number_of(url),
+    is_here: issue_file.is_same_repository(filing.target, filing.current)
+  });
+  await record_parks(url, filing);
+}
+async function record_solo(url, filing, labels) {
+  if (!has_label_name(labels, RUN_SOLO_LABEL)) return;
+  const { answers = {} } = filing.args;
+  const body = issue_run_verdict.comment_with_answers(RUN_SOLO_LABEL, { ...answers, solo: true });
+  try {
+    await git_gh_command.issue_comment(String(issue_number_of(url)), body, filing.target);
+  } catch (error) {
+    console.error(
+      `\u26A0 ${url} is already filed; could not record solo answers: ${error_text.message_of(error)}`
+    );
+  }
+}
+async function send(filing, labels) {
+  const url = await create(filing, labels);
+  if (url === void 0) return void 0;
+  console.info(url);
+  await record_solo(url, filing, labels);
+  await record2(url, filing, labels);
+  await link_release(url, filing);
+  await place(url, filing.target);
+  return url;
+}
+async function is_run_clear(filing) {
+  const prefix = issue_file_fold.reference_prefix(filing.target, filing.current);
+  return split_resolution.is_split_clear(filing.args) && await issue_file_cap.is_cap_clear(filing.args.found_during) && await issue_file_fold.is_fold_clear(prefix, filing.args) && await split_direction.is_direction_clear(filing.args, filing.body);
+}
+async function admitted_labels(filing) {
+  const party_problem = party_refusal(filing.target);
+  if (party_problem !== void 0) {
+    console.error(party_problem);
+    return void 0;
+  }
+  if (!await is_run_clear(filing)) return void 0;
+  return await issue_file_pass.labels_in_one_pass(filing);
+}
+async function file(filing) {
+  const labels = await admitted_labels(filing);
+  if (labels === void 0 || filing.args.is_check) return void 0;
+  return await send(filing, labels);
+}
+async function check(filing) {
+  if (await admitted_labels(filing) === void 0) return FAILURE_EXIT_CODE;
+  console.info(CHECK_CLEAR_MESSAGE);
+  return SUCCESS_EXIT_CODE;
+}
+async function filing_of(args) {
+  const read = cli_body.read_result(args.body_file);
+  if ("problem" in read) return `Could not read the body file ${args.body_file}: ${read.problem}`;
+  const body = issue_classification.with_release_classification(
+    read.text,
+    issue_file.labels_of(args, read.text)
+  );
+  const current = await git_gh_command.repo_get_name_with_owner();
+  if (current === void 0) return UNKNOWN_REPO_MESSAGE;
+  return { args, body, target: args.repo ?? current, current };
+}
+async function parsed_filing(argv) {
+  const args = issue_file.parse(argv);
+  if (args === void 0) {
+    console.error(USAGE);
+    return void 0;
+  }
+  const filing = await filing_of(args);
+  if (typeof filing === "object") return filing;
+  console.error(filing);
+  return void 0;
+}
+async function file_issue(argv, scouted) {
+  const filing = await parsed_filing(argv);
+  return filing === void 0 ? void 0 : await file({ ...filing, scouted });
+}
+async function scout(argv) {
+  const args = issue_file.parse(argv);
+  const filing = args === void 0 ? void 0 : await filing_of(args);
+  return typeof filing === "object" ? await issue_file_pass.scout_filing(filing) : void 0;
+}
+async function run(argv) {
+  const filing = await parsed_filing(argv);
+  if (filing === void 0) return FAILURE_EXIT_CODE;
+  if (filing.args.is_check) return await check(filing);
+  return await file(filing) === void 0 ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE;
+}
+var issue_file_cli = {
+  THIRD_PARTY_MESSAGE,
+  UNKNOWN_PARTY_MESSAGE,
+  file_issue,
+  record: record2,
+  run,
+  scout
+};
+
+export {
+  issue_file_cli
+};