@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-XTJA34ND.js

@@ -0,0 +1,492 @@
+import {
+  review_size
+} from "./chunk-HAT7AFBF.js";
+import {
+  lane_session_broker
+} from "./chunk-4MGTNY2L.js";
+import {
+  run_ship_review
+} from "./chunk-KD3SEAMV.js";
+import {
+  issue_declared_size
+} from "./chunk-CC4BIGCA.js";
+import {
+  split_measure
+} from "./chunk-P6ASP2DY.js";
+import {
+  removed_tests_check
+} from "./chunk-EN65ZS3S.js";
+import {
+  review_reviewed_tree
+} from "./chunk-ZGBXUY7R.js";
+import {
+  review_comment_round
+} from "./chunk-2OEXY4GM.js";
+import {
+  issue_watch_gate
+} from "./chunk-6KUA7MRG.js";
+import {
+  test_related_verdict
+} from "./chunk-BAEDHPXW.js";
+import {
+  review_brief,
+  review_fix_round,
+  review_round
+} from "./chunk-GVDRRBHZ.js";
+import {
+  review_round_one_blobs
+} from "./chunk-JGX7JIW4.js";
+import {
+  review_untouched_readers
+} from "./chunk-U46YTYJQ.js";
+import {
+  review_interaction
+} from "./chunk-IOKOHB7P.js";
+import {
+  review_level
+} from "./chunk-T6JUDQMW.js";
+import {
+  review_diff_parts
+} from "./chunk-MY3RSOS5.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  path_decision
+} from "./chunk-JI2EGXZX.js";
+import {
+  review_code_tree
+} from "./chunk-62NYXZCC.js";
+import {
+  review_attest,
+  review_checkout
+} from "./chunk-URZ4RDC4.js";
+import {
+  observation_ledger_home
+} from "./chunk-QXBOECGL.js";
+import {
+  bash_output_cap_reader
+} from "./chunk-JFLFGLE4.js";
+import {
+  scoped_green
+} from "./chunk-7E43YW53.js";
+import {
+  review_stamps
+} from "./chunk-XSKJAG72.js";
+import {
+  review_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  find_package_directory
+} from "./chunk-LR22UK5W.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+import {
+  REVIEW_GATE_SCHEMA,
+  package_manifest
+} from "./chunk-WB4T3VY2.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/review/review-brief-cli.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// scripts/review/review-diff-write.ts
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+// scripts/review/review-diff-pack.ts
+function fits(bundle, part, cap) {
+  return bundle !== void 0 && bundle.text.length + part.length <= cap;
+}
+function add(bundles, relative, part, cap) {
+  const last = bundles.at(-1);
+  if (!fits(last, part, cap)) {
+    bundles.push({ text: part, paths: [relative] });
+    return;
+  }
+  last.text += part;
+  if (last.paths.at(-1) !== relative) last.paths.push(relative);
+}
+function pack(entries, cap) {
+  const bundles = [];
+  for (const entry of entries) {
+    for (const part of entry.parts) add(bundles, entry.relative, part, cap);
+  }
+  return bundles;
+}
+function parts_of(written) {
+  const parts = {};
+  for (const { file, paths } of written) {
+    for (const relative of paths) parts[relative] = [...parts[relative] ?? [], file];
+  }
+  return parts;
+}
+var review_diff_pack = { pack, parts_of };
+
+// scripts/review/review-diff-write.ts
+var DIRECTORY_PREFIX = "josh-review-diff-";
+var DIRECTORY_MODE = 448;
+var FILE_MODE = 384;
+var PART_SUFFIX = ".diff";
+var INDEX_WIDTH = 3;
+var NUL = "\0";
+var SLUG_SEPARATOR = "__";
+function untracked_text(root, relative) {
+  try {
+    const content = readFileSync(path.join(root, relative), "utf8");
+    if (content.includes(NUL)) return `untracked binary file ${relative}, not shown
+`;
+    return `untracked file ${relative}, shown whole:
+${content}`;
+  } catch {
+    return `${relative} is listed by the change but holds no diff and no file
+`;
+  }
+}
+async function path_diff(root, base, relative) {
+  const diff = await git_spawn.read(["-C", root, "diff", "--no-color", base, "--", relative]);
+  return diff.length > 0 ? diff : untracked_text(root, relative);
+}
+function part_name(position, bundle) {
+  const prefix = String(position).padStart(INDEX_WIDTH, "0");
+  const [first = ""] = bundle.paths;
+  return `${prefix}-${first.split("/").join(SLUG_SEPARATOR)}${PART_SUFFIX}`;
+}
+function write_bundle(directory, bundle, position) {
+  const file = path.join(directory, part_name(position, bundle));
+  writeFileSync(file, bundle.text, { flag: "wx", mode: FILE_MODE });
+  return file;
+}
+function fresh_directory(root) {
+  const directory = stamp_file.stamp_path(DIRECTORY_PREFIX, root, "");
+  rmSync(directory, { recursive: true, force: true });
+  mkdirSync(directory, { mode: DIRECTORY_MODE });
+  return directory;
+}
+async function write_parts(request, directory) {
+  const { root, base, paths, cap } = request;
+  const texts = await Promise.all(
+    paths.map(async (relative) => ({ relative, text: await path_diff(root, base, relative) }))
+  );
+  const target = directory ?? fresh_directory(root);
+  const entries = texts.map(({ relative, text }) => ({
+    relative,
+    parts: review_diff_parts.part_texts(relative, text, cap)
+  }));
+  const bundles = review_diff_pack.pack(entries, cap);
+  return review_diff_pack.parts_of(
+    bundles.map((bundle, position) => ({
+      file: write_bundle(target, bundle, position),
+      paths: bundle.paths
+    }))
+  );
+}
+var review_diff_write = { path_diff, write_parts };
+
+// scripts/review/review-gate-mode.ts
+var ENV_KEY = "JOSH_REVIEW_GATE";
+var DEFAULT_MODE = "local";
+function read(directory = process.cwd()) {
+  return REVIEW_GATE_SCHEMA.safeParse(process.env[ENV_KEY]).data ?? package_manifest.read_nearest_value(
+    directory,
+    package_manifest.josh_schemas.review_gate,
+    function select_mode(manifest) {
+      return manifest.josh?.review_gate;
+    }
+  ) ?? DEFAULT_MODE;
+}
+var review_gate_mode = { read };
+
+// scripts/review/review-round-one-skip.ts
+var NOTE = "round1: skipped-in-size";
+var BLOCKING = /* @__PURE__ */ new Set(["high", "medium"]);
+var KINDS = ["code", "interaction"];
+async function is_in_size(issue) {
+  const declared = await issue_declared_size.read(String(issue));
+  if (declared === void 0 || Math.min(declared.files, declared.lines) <= 0) return false;
+  const actual = await split_measure.read_branch();
+  return actual.files <= declared.files && actual.lines <= declared.lines;
+}
+async function is_eligible(issue) {
+  if (!await is_in_size(issue)) return false;
+  const content = await observation_ledger_home.read(void 0, true);
+  if (content === void 0) return false;
+  const comments = await review_comment_round.issue_lines(issue);
+  const history = [content, ...comments].join("\n");
+  return KINDS.every(
+    (kind) => review_finding_ledger.issue_dispositions(history, issue, kind).every((line) => !BLOCKING.has(line.severity))
+  );
+}
+async function eligible_issue() {
+  if (review_gate_mode.read() !== "local") return void 0;
+  try {
+    const issue = git_branch.issue_from_branch(await git_command.branch());
+    return issue !== void 0 && await is_eligible(issue) ? issue : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function record(issue) {
+  await lane_ledger_write.record_round_one({ issue, verdict: "skipped" });
+  process.stderr.write(`${NOTE}
+`);
+}
+async function run(issue, review) {
+  const is_skipped = issue !== void 0;
+  const result = await review(is_skipped ? review_round.SECOND_ROUND : 1, is_skipped);
+  if (result === 0 && issue !== void 0) await record(issue);
+  return result;
+}
+var review_round_one_skip = { eligible_issue, record, run, NOTE };
+
+// scripts/review/review-brief-cli.ts
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/review/review-brief-cli.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var USAGE = "Usage: josh review:brief [--round <1|2> | --full-change] | --interaction | --level-only [--staged] [--json]";
+var MODULE_DIRECTORY = path2.dirname(fileURLToPath(__josh_source_url));
+var RUBRIC_PATH = path2.join(
+  find_package_directory(MODULE_DIRECTORY),
+  review_brief.RUBRIC_RELATIVE_PATH
+);
+var LEVEL_ONLY_FLAG = "--level-only";
+var INTERACTION_FLAG = "--interaction";
+var LEVEL_KEY = "level";
+var FIRST_ROUND = 1;
+var FAILURE_EXIT_CODE = 1;
+var KEPT_NOTE_PREFIX = "Round-1 snapshot: kept the record taken at";
+function kept_note(taken_at) {
+  return `${KEPT_NOTE_PREFIX} ${taken_at} rather than retaking it \u2014 the fix delta is measured from there, so everything changed since is reviewed rather than assumed away. Check that timestamp: a record left behind by an earlier run measures the delta from further back, which widens the round rather than narrowing it (joshuafolkken/kit#1441).`;
+}
+function record_round_one(round, tree, base, target) {
+  if (round !== FIRST_ROUND) return false;
+  try {
+    const recorded = review_stamps.round_one_stamp.read(target);
+    if (recorded !== void 0) {
+      console.error(kept_note(recorded.taken_at));
+      return false;
+    }
+    const blobs = review_round_one_blobs.capture(Object.keys(tree));
+    review_stamps.round_one_stamp.write(tree, target, base, blobs);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findings_tree(checkout) {
+  const { findings } = lane_session_broker.review_paths(PROJECT_ROOT);
+  const briefed = review_stamps.briefed_stamp.read();
+  if (briefed === void 0 || !review_attest.is_briefed_since(briefed.taken_at, checkout.root)) {
+    return void 0;
+  }
+  const is_clean = review_attest.is_reviewed_on(checkout, findings, checkout.root) && run_ship_review.is_clean_round_one(stamp_file.read_stamp_text(findings));
+  return is_clean ? briefed : void 0;
+}
+function attested_tree(checkout) {
+  return review_reviewed_tree.resume_point(checkout) ?? findings_tree(checkout);
+}
+function slot_of(interaction) {
+  const { CODE, INTERACTION } = review_attest.REVIEW_SLOT;
+  return interaction === void 0 ? CODE : INTERACTION;
+}
+async function open_contract(slot) {
+  const checkout = await review_checkout.read_checkout();
+  const is_code = slot === review_attest.REVIEW_SLOT.CODE;
+  const resumed_from = is_code ? attested_tree(checkout) : void 0;
+  const fix_round = is_code ? review_fix_round.resume(checkout) : void 0;
+  const nonce = review_attest.record_target(checkout, checkout.root, slot);
+  return { checkout, nonce, resumed_from, fix_round };
+}
+function record_briefed(tree, base) {
+  try {
+    const blobs = review_round_one_blobs.capture(Object.keys(tree));
+    review_stamps.briefed_stamp.write(tree, void 0, base, blobs);
+  } catch {
+  }
+}
+async function read_diff(root, base, paths) {
+  const cap = bash_output_cap_reader.bash_output_cap(root);
+  try {
+    return { parts: await review_diff_write.write_parts({ root, base, paths, cap }), cap };
+  } catch {
+    return void 0;
+  }
+}
+async function read_removed_tests() {
+  try {
+    return await removed_tests_check.read() ?? [];
+  } catch {
+    return [];
+  }
+}
+async function read_readers(root, base, paths) {
+  try {
+    return await review_untouched_readers.read({ root, base, paths });
+  } catch {
+    return review_untouched_readers.FAILED_READ;
+  }
+}
+async function compose_brief(request) {
+  const { round, paths, tree, base, profile, interaction } = request;
+  const contract = await open_contract(slot_of(interaction));
+  const stamps = {
+    gate: review_stamps.gate_stamp.read(),
+    in_flight: review_stamps.in_flight_stamp.read(),
+    round_one: review_stamps.round_one_stamp.read()
+  };
+  return review_brief.compose({
+    is_full_change: request.is_full_change,
+    level: request.level,
+    profile,
+    round,
+    tree,
+    stamps,
+    // Resolved by the caller rather than printed as a `$(…)` the forked agent would expand: a
+    // subshell that fails expands to nothing, and the bare `git diff` left behind lists only the
+    // unstaged working tree — a review silently narrowed to a fraction of the change.
+    // One reading is shared with the record written below, so the commit
+    // the map is stored against is the same one the brief printed.
+    base,
+    rubric_path: RUBRIC_PATH,
+    ...contract,
+    diff: await read_diff(contract.checkout.root, base, paths),
+    readers: await read_readers(contract.checkout.root, base, paths),
+    removed_tests: await read_removed_tests(),
+    interaction,
+    high_cited: review_reviewed_tree.high_cited()
+  });
+}
+async function read_bases() {
+  const commit = await change_base.resolved_through_merge();
+  return { base: commit ?? await git_command.change_base(), commit };
+}
+function report_error(message) {
+  console.error(message);
+  return FAILURE_EXIT_CODE;
+}
+async function run_level(argv) {
+  return await path_decision.run_path_decision(argv, {
+    usage: USAGE,
+    key: LEVEL_KEY,
+    decide: async (paths, is_staged) => {
+      const lines = await review_size.read(paths, is_staged);
+      return review_level.level_for(paths, lines);
+    },
+    explain: review_level.format_reason
+  });
+}
+function refusal_for_round(reading, round) {
+  const { tree, commit } = reading;
+  const refusal = scoped_green.refusal_for(tree, commit);
+  if (refusal === void 0 || round === FIRST_ROUND) return refusal;
+  return scoped_green.refusal_for(tree, commit, { test: test_related_verdict.touched_target() });
+}
+async function read_change() {
+  const { base, commit } = await read_bases();
+  const paths = await changed_paths.read_changed_paths(false);
+  const tree = await review_tree.read_changed_tree(paths);
+  const lines = await review_size.read(paths);
+  return { base, commit, paths, tree, level: review_level.level_for(paths, lines) };
+}
+async function record_review(round, tree, commit) {
+  const is_snapshot_written = record_round_one(round, tree, commit);
+  if (is_snapshot_written) await review_code_tree.record(Object.keys(tree), commit);
+  record_briefed(tree, commit);
+  review_round.record(round);
+}
+async function run_review(round, reading, emit, options = {}) {
+  const { commit, tree, level } = reading;
+  const refusal = refusal_for_round(reading, round);
+  if (refusal !== void 0) return report_error(refusal);
+  const resolved = agent_role_profile.resolve_review(round, process.env, level === "low");
+  if (resolved.kind === "rejected") return report_error(resolved.note);
+  agent_role_profile.warn_of_default();
+  emit(await compose_brief({ ...reading, round, profile: resolved.profile, ...options }));
+  if (options.interaction === void 0) await record_review(round, tree, commit);
+  return 0;
+}
+async function run_interaction(emit) {
+  const reading = await read_change();
+  const targets = review_interaction.due_paths(reading.paths);
+  if (targets.length === 0) {
+    emit(review_interaction.NOT_DUE_LINE);
+    return 0;
+  }
+  const stale = await issue_watch_gate.review_refusal_here();
+  if (stale !== void 0) return report_error(stale);
+  return await run_review(FIRST_ROUND, reading, emit, { interaction: targets });
+}
+async function scoped_refusal() {
+  const { tree, commit } = await read_change();
+  return scoped_green.refusal_for(tree, commit);
+}
+var REVIEWER_REFUSAL = "review:brief refused: this is a reviewer session (JOSH_AGENT_ROLE=reviewer). A new brief would drop the attestation this review already left \u2014 review the brief you were handed and report.";
+async function run_brief(argv, emit) {
+  if (argv.length === 0) {
+    return await review_round_one_skip.run(
+      await review_round_one_skip.eligible_issue(),
+      async (round2, is_full_change2) => await run_review(round2, await read_change(), emit, { is_full_change: is_full_change2 })
+    );
+  }
+  if (argv.length === 1 && argv[0] === INTERACTION_FLAG) return await run_interaction(emit);
+  const round = review_round.parse_round(argv);
+  if (round === void 0) return report_error(USAGE);
+  const is_full_change = argv.includes(review_round.FULL_CHANGE_FLAG);
+  return await run_review(round, await read_change(), emit, { is_full_change });
+}
+async function run_to(argv, emit) {
+  if (argv[0] === LEVEL_ONLY_FLAG) return await run_level(argv.slice(1));
+  if (agent_session_role.is_reviewer()) return report_error(REVIEWER_REFUSAL);
+  return await run_brief(argv, emit);
+}
+async function run2(argv) {
+  return await run_to(argv, console.info);
+}
+var review_brief_cli = {
+  attested_tree,
+  FIRST_ROUND,
+  format_reason: review_level.format_reason,
+  KEPT_NOTE_PREFIX,
+  parse_round: review_round.parse_round,
+  record_review,
+  record_round_one,
+  report_error,
+  run: run2,
+  run_to,
+  scoped_refusal
+};
+
+export {
+  review_brief_cli
+};

package/dist/commands/chunk-XUXCFPDK.js

@@ -0,0 +1,218 @@
+import {
+  lane_residents
+} from "./chunk-43H725LG.js";
+import {
+  lane_spent
+} from "./chunk-KR6WUAJM.js";
+import {
+  lane_plan
+} from "./chunk-MDGPJOLK.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  git_worktree
+} from "./chunk-WNBJK6QE.js";
+import {
+  lane_state
+} from "./chunk-7EAYFMDN.js";
+import {
+  lane_reap
+} from "./chunk-ON4IKRGS.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.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
+};