@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-MIZLGSHI.js

@@ -0,0 +1,419 @@
+import {
+  epic_decision,
+  epic_sections
+} from "./chunk-XSKB6ZUA.js";
+import {
+  epic_validate
+} from "./chunk-C7JEMYPV.js";
+import {
+  epic_fetch
+} from "./chunk-6PLIQCBG.js";
+import {
+  UNORDERED_DEPENDENCIES,
+  chain_links,
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  DEPENDENCY_ARROW,
+  format_dependency_link,
+  format_issue_references,
+  to_issue_reference
+} from "./chunk-2ADQ5XRD.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  EPIC_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/epic/epic-read.ts
+var UNKNOWN_REPO = "Could not read this repository from `git remote`, so the epic's relations cannot be keyed by repository \u2014 check `gh auth status` and that this is a checkout with an `origin` remote.";
+async function read_subject(epic_number) {
+  return epic_validate.parse_epic_subject(
+    await git_gh_command.issue_get_labels_and_body(String(epic_number))
+  );
+}
+async function read_recorded(body) {
+  const repo = await git_gh_command.repo_get_name_with_owner();
+  if (repo === void 0) return { error: UNKNOWN_REPO };
+  const tracked = epic_parse.parse_task_list_issue_numbers(body);
+  if (tracked.length === 0) return { children: [], repo };
+  const fetched = await epic_fetch.fetch_children(tracked, repo);
+  if (fetched.unreadable.length > 0) {
+    const list = epic_graph.format_references(fetched.unreadable, repo);
+    return { error: `Could not read ${list}; the epic's dependency graph is incomplete.` };
+  }
+  return { children: fetched.children, repo };
+}
+async function read_epic(epic_number) {
+  const subject = await read_subject(epic_number);
+  const unread = `Could not read issue ${session_cite.issue(epic_number)}.`;
+  if (subject === void 0) return { error: unread };
+  const recorded = await read_recorded(subject.body);
+  if ("error" in recorded) return { error: recorded.error };
+  return { subject, recorded: recorded.children, repo: recorded.repo };
+}
+var epic_read = {
+  read_subject,
+  read_epic
+};
+
+// scripts/epic/epic-chains.ts
+var AMBIGUOUS_MATCH_COUNT = 2;
+function render_chains(chains) {
+  return chains.filter((chain) => chain.length > 1).map((chain) => chain.map((number) => to_issue_reference(number)).join(DEPENDENCY_ARROW));
+}
+function links_of(chains) {
+  const links = chains.flatMap((chain) => chain_links(chain));
+  return [...new Map(links.map((link) => [format_dependency_link(link), link])).values()];
+}
+function diff_links(before, after) {
+  const before_links = links_of(before);
+  const after_links = links_of(after);
+  const before_keys = new Set(before_links.map((link) => format_dependency_link(link)));
+  const after_keys = new Set(after_links.map((link) => format_dependency_link(link)));
+  return {
+    added: after_links.filter((link) => !before_keys.has(format_dependency_link(link))),
+    removed: before_links.filter((link) => !after_keys.has(format_dependency_link(link)))
+  };
+}
+function chains_containing(chains, target) {
+  return chains.map((chain, index) => chain.includes(target) ? index : -1).filter((index) => index !== -1);
+}
+function find_repeated_reference(chains) {
+  for (const chain of chains) {
+    const repeated = chain.find((issue_number, index) => chain.indexOf(issue_number) !== index);
+    if (repeated !== void 0) return repeated;
+  }
+  return void 0;
+}
+function chain_for(additions, position) {
+  return position.kind === "before" ? [...additions, position.target] : [position.target, ...additions];
+}
+function start_chain(additions, position) {
+  return { chains: [chain_for(additions, position)] };
+}
+function add_chain(chains, additions, position) {
+  return { chains: [...chains.map((chain) => [...chain]), chain_for(additions, position)] };
+}
+function not_a_child_error(target) {
+  return {
+    error: `${to_issue_reference(target)} is not a child of this epic, so it cannot position an insertion.`
+  };
+}
+function insert_outside_chains(chains, additions, position, tracked) {
+  if (tracked.includes(position.target)) return add_chain(chains, additions, position);
+  return not_a_child_error(position.target);
+}
+function has_successor(chain, target) {
+  return chain.indexOf(target) < chain.length - 1;
+}
+function is_branching_after(chains, indices, position) {
+  if (position.kind !== "after") return false;
+  return indices.every((index) => has_successor(chains[index] ?? [], position.target));
+}
+function is_shared_before(chains, indices, position) {
+  if (position.kind !== "before") return false;
+  const predecessors = indices.map((index) => {
+    const chain = chains[index] ?? [];
+    return chain[chain.indexOf(position.target) - 1];
+  });
+  return predecessors.every((predecessor) => predecessor === predecessors[0]);
+}
+function is_single_place(chains, indices, position) {
+  return indices.length < AMBIGUOUS_MATCH_COUNT || is_shared_before(chains, indices, position);
+}
+function to_ambiguous_position_error(position) {
+  return `${to_issue_reference(position.target)} appears in more than one declared chain, so "${position.kind}" does not identify one place; edit the declaration by hand.`;
+}
+function find_position_ambiguity(chains, position) {
+  if (position?.kind !== "before" || is_single_place(chains, chains_containing(chains, position.target), position)) {
+    return void 0;
+  }
+  return to_ambiguous_position_error(position);
+}
+function splice_chain(chain, additions, position) {
+  const at = chain.indexOf(position.target) + (position.kind === "after" ? 1 : 0);
+  return [...chain.slice(0, at), ...additions, ...chain.slice(at)];
+}
+function splice_into_chains(chains, indices, additions, position) {
+  return {
+    chains: chains.map(
+      (chain, index) => indices.includes(index) ? splice_chain(chain, additions, position) : [...chain]
+    )
+  };
+}
+function insert_at_position(chains, additions, position, tracked) {
+  const indices = chains_containing(chains, position.target);
+  if (indices.length === 0) return insert_outside_chains(chains, additions, position, tracked);
+  if (is_branching_after(chains, indices, position)) return add_chain(chains, additions, position);
+  if (!is_single_place(chains, indices, position)) {
+    return { error: to_ambiguous_position_error(position) };
+  }
+  return splice_into_chains(chains, indices, additions, position);
+}
+function keep_declaration(chains) {
+  return { chains: chains.map((chain) => [...chain]) };
+}
+function start_chain_or_refuse(additions, position, tracked) {
+  if (!tracked.includes(position.target)) return not_a_child_error(position.target);
+  return start_chain(additions, position);
+}
+function apply_insertion(chains, additions, position, tracked) {
+  if (position === void 0) return keep_declaration(chains);
+  if (chains.length === 0) return start_chain_or_refuse(additions, position, tracked);
+  return insert_at_position(chains, additions, position, tracked);
+}
+function find_already_declared_addition(chains, additions) {
+  const declared = new Set(chains.flat());
+  return additions.find((addition) => declared.has(addition));
+}
+function already_declared_error(issue_number) {
+  const reference = to_issue_reference(issue_number);
+  return `${reference} is already named in the declared dependency order; inserting it again would have it block itself.`;
+}
+function find_insertion_error(chains, additions) {
+  const repeated = find_repeated_reference(chains);
+  if (repeated !== void 0) {
+    return `The declared dependency order names ${to_issue_reference(repeated)} twice; fix the declaration before inserting.`;
+  }
+  const declared = find_already_declared_addition(chains, additions);
+  return declared === void 0 ? void 0 : already_declared_error(declared);
+}
+function remove_children(chains, children) {
+  const dropped = new Set(children);
+  return chains.map((chain) => chain.filter((issue_number) => !dropped.has(issue_number))).filter((chain) => chain.length > 1);
+}
+function break_indices(chain, dropped) {
+  return chain.map((blocked, index) => {
+    const blocker = chain[index - 1];
+    return blocker !== void 0 && dropped.has(format_dependency_link({ blocker, blocked })) ? index : -1;
+  }).filter((index) => index !== -1);
+}
+function split_chain(chain, dropped) {
+  const bounds = [0, ...break_indices(chain, dropped), chain.length];
+  return bounds.slice(0, -1).map((start, index) => chain.slice(start, bounds[index + 1]));
+}
+function remove_links(chains, links) {
+  const dropped = new Set(links.map((link) => format_dependency_link(link)));
+  return chains.flatMap((chain) => split_chain(chain, dropped)).filter((chain) => chain.length > 1);
+}
+function insert_children(chains, additions, position, tracked) {
+  const error = find_insertion_error(chains, additions);
+  if (error !== void 0) return { error };
+  const outcome = apply_insertion(chains, additions, position, tracked);
+  if ("error" in outcome) return outcome;
+  const duplicated = find_repeated_reference(outcome.chains);
+  return duplicated === void 0 ? outcome : { error: already_declared_error(duplicated) };
+}
+var epic_chains = {
+  render_chains,
+  links_of,
+  diff_links,
+  find_position_ambiguity,
+  // Exported so `--order-before` / `--order-after` can pass the
+  // declaration through by the same function `--add` without a position uses. An order-only move is
+  // "leave the declaration exactly as it stood" applied to a call that *does* name a position, so a
+  // second copy of the passthrough would be the clone `CLAUDE.md` prohibits.
+  keep_declaration,
+  remove_children,
+  remove_links,
+  insert_children
+};
+
+// scripts/epic/epic-add-body.ts
+var { find_indices, is_in_range, to_body_lines } = epic_sections;
+function to_task_row(issue_number) {
+  return `- [ ] ${to_issue_reference(issue_number)}`;
+}
+function to_task_rows(placed) {
+  return placed.map((issue_number) => to_task_row(issue_number));
+}
+function append_task_rows(input, placed) {
+  const rows = find_indices(input, (line) => epic_parse.is_task_list_line(line));
+  const last = rows.at(-1);
+  if (last === void 0) return [...input.lines];
+  return [
+    ...input.lines.slice(0, last + 1),
+    ...to_task_rows(placed),
+    ...input.lines.slice(last + 1)
+  ];
+}
+function to_row_number(line) {
+  const [issue_number] = epic_parse.parse_task_list_issue_numbers(line);
+  return issue_number;
+}
+function is_placed_row(line, placed) {
+  const issue_number = to_row_number(line);
+  return issue_number !== void 0 && placed.has(issue_number);
+}
+function insert_task_rows(input, placed, position) {
+  const moved = new Set(placed);
+  const dropped = new Set(find_indices(input, (line) => is_placed_row(line, moved)));
+  const kept = input.lines.filter((_line, index) => !dropped.has(index));
+  const [at] = find_indices(to_body_lines(kept), (line) => to_row_number(line) === position.target);
+  if (at === void 0) return [...input.lines];
+  const insert_at = position.kind === "before" ? at : at + 1;
+  return [...kept.slice(0, insert_at), ...to_task_rows(placed), ...kept.slice(insert_at)];
+}
+function to_placed_lines(input) {
+  const lines = to_body_lines(input.body);
+  const { position } = input;
+  if (position === void 0) return append_task_rows(lines, input.placed);
+  return insert_task_rows(lines, input.placed, position);
+}
+var DEPENDENCIES_HEADING = /^#{1,6}[ \t]+Dependencies\b/u;
+function find_dependencies_range(input) {
+  return epic_sections.find_section_range(input, DEPENDENCIES_HEADING);
+}
+function splice_declaration(lines, input) {
+  return lines.flatMap((line, index) => {
+    if (index === input.first) return [...input.rendered];
+    if (input.dropped.has(index)) return [];
+    return [line];
+  });
+}
+function replace_declaration(lines, rendered) {
+  const input = to_body_lines(lines);
+  const range = find_dependencies_range(input);
+  if (range === void 0) return void 0;
+  const found = find_indices(input, (line) => epic_parse.is_declaration_line(line));
+  const declarations = found.filter((index) => is_in_range(index, range));
+  const [first] = declarations;
+  return first === void 0 ? [...lines.slice(0, range.end), ...rendered, ...lines.slice(range.end)] : splice_declaration(lines, { first, dropped: new Set(declarations.slice(1)), rendered });
+}
+function to_safe_declaration(line) {
+  const [rendered] = epic_chains.render_chains(epic_parse.parse_dependency_chains(line));
+  return rendered ?? UNORDERED_DEPENDENCIES;
+}
+function find_stray_declaration(lines) {
+  const input = to_body_lines(lines);
+  const range = find_dependencies_range(input);
+  if (range === void 0) return void 0;
+  const stray = find_indices(input, (line) => epic_parse.is_declaration_line(line)).find(
+    (index) => !is_in_range(index, range)
+  );
+  return stray === void 0 ? void 0 : to_safe_declaration(lines[stray] ?? "");
+}
+function to_written_lines(input) {
+  const with_rows = to_placed_lines(input);
+  const { decision } = input;
+  if (decision === void 0) return with_rows;
+  return epic_decision.append_decision(with_rows.join("\n"), decision).split("\n");
+}
+function is_declaration_unchanged(lines, rendered) {
+  const declared = epic_parse.parse_dependency_chains(lines.join("\n"));
+  return epic_chains.render_chains(declared).join("\n") === rendered.join("\n");
+}
+function to_declared_body(with_rows, rendered) {
+  const stray = find_stray_declaration(with_rows);
+  if (stray !== void 0) {
+    return {
+      error: `The body declares \`${stray}\` outside the \`Dependencies\` section, which no insertion can keep consistent; move it into that section or reword it first.`
+    };
+  }
+  if (is_declaration_unchanged(with_rows, rendered)) return { body: with_rows.join("\n") };
+  const replaced = replace_declaration(with_rows, rendered);
+  return replaced === void 0 ? { error: "Could not locate the `Dependencies` section to rewrite; nothing was written." } : { body: replaced.join("\n") };
+}
+function to_rendered_declaration(input) {
+  const rendered = epic_chains.render_chains(input.chains_after);
+  if (rendered.length > 0) return rendered;
+  return input.does_clear_declaration === true ? [UNORDERED_DEPENDENCIES] : [];
+}
+function build_body(input) {
+  const with_rows = to_written_lines(input);
+  const rendered = to_rendered_declaration(input);
+  if (rendered.length === 0) return { body: with_rows.join("\n") };
+  return to_declared_body(with_rows, rendered);
+}
+function to_link_keys(chains) {
+  return epic_chains.links_of(chains).map((link) => format_dependency_link(link)).toSorted((left, right) => left.localeCompare(right));
+}
+function has_intended_links(body, chains_after) {
+  const written = to_link_keys(epic_parse.parse_dependency_chains(body));
+  const intended = to_link_keys(chains_after);
+  return written.length === intended.length && written.every((key, index) => key === intended[index]);
+}
+function missing_rows(body, expected) {
+  const tracked = epic_parse.parse_task_list_issue_numbers(body);
+  return expected.filter((issue_number) => !tracked.includes(issue_number));
+}
+function to_placement_start(position, target, count) {
+  return position.kind === "before" ? target - count : target + 1;
+}
+function has_intended_rows(body, input) {
+  const { position, placed } = input;
+  if (position === void 0 || placed.length === 0) return true;
+  const tracked = epic_parse.parse_task_list_issue_numbers(body);
+  const target = tracked.indexOf(position.target);
+  if (target === -1) return false;
+  const start = to_placement_start(position, target, placed.length);
+  return placed.every((child, offset) => tracked[start + offset] === child);
+}
+function find_rewrite_error(body, input) {
+  const missing = missing_rows(body, input.placed);
+  if (missing.length > 0) {
+    return `The rewritten body would not track ${format_issue_references(missing)} as a task-list row.`;
+  }
+  if (!epic_parse.has_machine_readable_declaration(body)) {
+    return "The rewritten body would carry no unambiguous machine-readable `Dependencies` declaration.";
+  }
+  if (!has_intended_links(body, input.chains_after)) {
+    return "The rewritten body would declare a different dependency order than the one computed; nothing was written.";
+  }
+  if (!has_intended_rows(body, input)) {
+    return "The rewritten body would not put the placed task-list rows where the position asked; nothing was written.";
+  }
+  return void 0;
+}
+function rewrite_body(input) {
+  const built = build_body(input);
+  if ("error" in built) return built;
+  const error = find_rewrite_error(built.body, input);
+  return error === void 0 ? built : { error };
+}
+var epic_add_body = {
+  rewrite_body
+};
+
+// scripts/epic/epic-shape.ts
+function missing_declaration_error(epic_number) {
+  const check = `josh epic:check ${String(epic_number)}`;
+  return `${to_issue_reference(epic_number)} has no unambiguous machine-readable \`Dependencies\` declaration; run \`${check}\` first.`;
+}
+function promote_remedy(epic_number) {
+  const promote = `josh epic --promote ${String(epic_number)} <N...>`;
+  return `Promote it with \`${promote}\` when it is a request, a discussion or a container; create a new epic over both when it is itself one of the deliverables.`;
+}
+function find_epic_shape_error(subject) {
+  if (has_label_name(subject.labels, EPIC_LABEL)) return void 0;
+  return `${to_issue_reference(subject.epic_number)} does not carry the \`${EPIC_LABEL}\` label, so it is not an epic. ${promote_remedy(subject.epic_number)}`;
+}
+function find_subject_error(subject, tracked) {
+  const reference = to_issue_reference(subject.epic_number);
+  if (subject.body === void 0) return `Could not read the body of ${reference}.`;
+  const shape_error = find_epic_shape_error(subject);
+  if (shape_error !== void 0) return shape_error;
+  if (tracked.length === 0) {
+    return `${reference} tracks no child as a \`- [ ] #N\` row; there is nowhere to add one.`;
+  }
+  return epic_parse.has_machine_readable_declaration(subject.body) ? void 0 : missing_declaration_error(subject.epic_number);
+}
+var epic_shape = {
+  find_subject_error
+};
+
+export {
+  epic_chains,
+  epic_add_body,
+  epic_shape,
+  epic_read
+};

package/dist/commands/chunk-MKIHWQ65.js

@@ -0,0 +1,218 @@
+import {
+  lane_residents
+} from "./chunk-GX5XHW2F.js";
+import {
+  lane_spent
+} from "./chunk-QN3FWRDW.js";
+import {
+  lane_plan
+} from "./chunk-JUQN3OXG.js";
+import {
+  lane_registry
+} from "./chunk-KXZR7UAE.js";
+import {
+  git_worktree
+} from "./chunk-2AH73ZTW.js";
+import {
+  lane_state
+} from "./chunk-V36OV7AP.js";
+import {
+  lane_reap
+} from "./chunk-VFW6XZH7.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/lane/lane-close.ts
+import { existsSync, rmSync } from "node:fs";
+
+// scripts/lane/lane-reap-settle.ts
+import { userInfo } from "node:os";
+var GRACE_MS = 3e3;
+var KILL_WAIT_MS = 1e3;
+var KILL_SIGNAL = "SIGKILL";
+var STATE_FORMAT = ["-o", "user=,stat=", "-p"];
+var FIELD_SEPARATOR = /\s+/u;
+var UNREADABLE_TEXT = "the lane's processes (lsof or ps failed)";
+function kill(pid) {
+  try {
+    process.kill(pid, KILL_SIGNAL);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function wait(milliseconds) {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function reason_from(user, state) {
+  if (user !== userInfo().username) return `owned by ${user}`;
+  return `state ${state}`;
+}
+function reason_of(pid) {
+  const printed = lane_reap.run_probe(lane_reap.PS_COMMAND, [...STATE_FORMAT, String(pid)]);
+  const [user = "", state = ""] = printed.trim().split(FIELD_SEPARATOR);
+  return user.length === 0 ? "unreadable" : reason_from(user, state);
+}
+var SYSTEM_PROBES = {
+  residents: (lane) => lane_residents.residents(lane),
+  kill,
+  wait,
+  reason_of
+};
+function is_empty(reading) {
+  return reading?.length === 0;
+}
+async function kill_all(lingering, probes) {
+  const targets = lingering ?? [];
+  for (const pid of targets) probes.kill(pid);
+  await probes.wait(KILL_WAIT_MS);
+}
+function survivors(lane, probes) {
+  return probes.residents(lane)?.map((pid) => ({ pid, reason: probes.reason_of(pid) }));
+}
+async function settle(lane, probes = SYSTEM_PROBES) {
+  if (is_empty(probes.residents(lane))) return [];
+  await probes.wait(GRACE_MS);
+  const lingering = probes.residents(lane);
+  if (is_empty(lingering)) return [];
+  await kill_all(lingering, probes);
+  return survivors(lane, probes);
+}
+function survivor_texts(settled) {
+  if (settled === void 0) return [UNREADABLE_TEXT];
+  return settled.map((survivor) => `process ${String(survivor.pid)} (${survivor.reason})`);
+}
+var lane_reap_settle = { GRACE_MS, KILL_WAIT_MS, reason_from, settle, survivor_texts };
+
+// scripts/lane/lane-close.ts
+async function ignore_failure(action) {
+  try {
+    await action();
+  } catch {
+  }
+}
+function lane_targets(root, issue, lane) {
+  return {
+    directory: lane?.directory ?? lane_paths.lane_directory(root, issue),
+    branch: lane?.branch ?? lane_paths.lane_branch(issue)
+  };
+}
+function remove_directory(directory) {
+  try {
+    rmSync(directory, { force: true, recursive: true });
+  } catch {
+  }
+}
+async function remove_lane(targets) {
+  await ignore_failure(async () => await git_worktree.worktree_remove(targets.directory));
+  remove_directory(targets.directory);
+  await ignore_failure(async () => await git_worktree.worktree_prune());
+  await ignore_failure(async () => await git_worktree.branch_delete(targets.branch));
+}
+async function residue(targets) {
+  const left = [];
+  if (existsSync(targets.directory)) left.push(targets.directory);
+  if (await git_command.branch_exists(targets.branch)) left.push(targets.branch);
+  return left;
+}
+function close_kind(did_exist, left_behind) {
+  if (left_behind.length > 0) return "incomplete";
+  return did_exist ? "closed" : "none";
+}
+async function resolve_lane(issue) {
+  const root = await lane_registry.lane_root_directory();
+  const existing = lane_registry.find_lane(await lane_registry.list_lanes(), issue);
+  return { existing, targets: lane_targets(root, issue, existing) };
+}
+async function is_ending(issue, kind) {
+  if (kind !== "none") return kind === "closed";
+  const record = await lane_state.read_state(issue);
+  return record !== void 0 && record.state !== "ended";
+}
+async function survivors_of(issue, directory) {
+  const survivors2 = await lane_reap_settle.settle({ issue, directory });
+  if (survivors2 !== void 0) await lane_state.record_stuck(issue, survivors2);
+  return lane_reap_settle.survivor_texts(survivors2);
+}
+async function left_behind_of(issue, targets) {
+  const survivors2 = await survivors_of(issue, targets.directory);
+  return [...await residue(targets), ...survivors2];
+}
+async function record_end(issue) {
+  await lane_state.record_change({ issue, state: "ended", command: "lane:close" });
+  lane_plan.release(Number(issue), process.cwd());
+}
+async function close_lane(issue) {
+  const { existing, targets } = await resolve_lane(issue);
+  const did_exist = existing !== void 0 || existsSync(targets.directory);
+  const reaped = lane_reap.reap_child({ issue, directory: targets.directory });
+  const residents = lane_residents.end_residents({ issue, directory: targets.directory }, reaped);
+  await remove_lane(targets);
+  const left_behind = await left_behind_of(issue, targets);
+  const kind = close_kind(did_exist, left_behind);
+  if (await is_ending(issue, kind)) await record_end(issue);
+  return { issue, kind, left_behind, reaped, residents };
+}
+async function always_due() {
+  return true;
+}
+async function try_close(issue) {
+  try {
+    const outcome = await close_lane(issue);
+    return outcome.kind !== "incomplete";
+  } catch (error) {
+    error_text.trace_swallowed("lane_close.try_close", error);
+    return false;
+  }
+}
+async function close_into(sweep, issue, is_due) {
+  if (!await is_due(issue)) return;
+  const bucket = await try_close(issue) ? sweep.closed : sweep.failed;
+  bucket.push(issue);
+}
+async function close_each(issues, is_due = always_due) {
+  const sweep = { closed: [], failed: [] };
+  for (const issue of issues) {
+    await close_into(sweep, issue, is_due);
+  }
+  return sweep;
+}
+async function prune_lanes() {
+  const lanes = await lane_registry.list_lanes();
+  const { spent, kept } = await lane_spent.sort_lanes(lanes);
+  const doomed = lanes.filter((lane) => lane.is_stranded || spent.includes(lane));
+  const sweep = await close_each(doomed.map((lane) => lane.issue));
+  return { ...sweep, kept };
+}
+async function close_all_lanes() {
+  const lanes = await lane_registry.list_lanes();
+  return await close_each(lanes.map((lane) => lane.issue));
+}
+async function is_unfinished(issue) {
+  const { targets } = await resolve_lane(issue);
+  return !existsSync(targets.directory);
+}
+async function retry_closes() {
+  const records = await lane_state.read_records();
+  const issues = records.filter((record) => record.state !== "ended").map(({ issue }) => issue);
+  return await close_each(issues, is_unfinished);
+}
+var lane_close = {
+  close_all_lanes,
+  close_lane,
+  prune_lanes,
+  resolve_lane,
+  retry_closes
+};
+
+export {
+  lane_reap_settle,
+  lane_close
+};