@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-OKN63ZH5.js

@@ -0,0 +1,109 @@
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/run/event/run-event-setup.ts
+var STAGE = {
+  // `josh backlogrun` started the parent session, which is reading its procedure.
+  STARTING: "starting session",
+  // `run:carry --begin` claimed the run, and the parent is planning it.
+  PLANNING: "planning",
+  // The supervisor took the run over from the parent and is asking for the first offer.
+  HANDING_OFF: "handing off",
+  // No child is runnable; maintenance may still be finishing before the replaceable drain.
+  WATCHING: "watching",
+  // The driver answered something only a session can act on — an untriaged child, an epic left to a
+  // person — and the supervisor is waking one. The next hand-off replaces it.
+  JUDGING: "waiting on judgment",
+  // The supervisor started that session, which is now acting on the driver's answer. It is detached, so
+  // its end is the supervisor's next hand-off, which replaces this.
+  SESSION: "judgment session running",
+  // The driver read a drain owing the retrospective and is waiting on the retrospective unit it
+  // started (joshuafolkken/kit#6745). The unit's end is the driver's next stage, which replaces this.
+  RETROSPECTIVE: "retrospective",
+  // The driver's launch of a lane returned without a child: no lane was free to open, or a step after
+  // the open failed. Written through `no_child`, naming its issue, so it ends that lane's stage alone
+  // while the pass's other launches run on (joshuafolkken/kit#5519).
+  NO_CHILD: "no child launched"
+};
+var OPENING = "opening lane";
+var INSTALLING = "installing dependencies";
+var DISPATCHING = "dispatching";
+var LANE_STAGE = { OPENING, INSTALLING, DISPATCHING };
+function opening_lane(issue) {
+  return `${OPENING} ${issue_cite.plain_for("program", issue)}`;
+}
+function installing(issue) {
+  return `${INSTALLING} ${issue_cite.plain_for("program", issue)}`;
+}
+function dispatching(issue) {
+  return `${DISPATCHING} ${issue_cite.plain_for("program", issue)}`;
+}
+function no_child(issue) {
+  return `${STAGE.NO_CHILD} ${issue_cite.plain_for("program", issue)}`;
+}
+async function emit(text) {
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.SETUP, text);
+}
+function append_stage(resolve_target, text, at) {
+  try {
+    const { SETUP } = run_event_stream.EVENT_KIND;
+    run_event_stream.append(resolve_target(), SETUP, text, at.toISOString());
+  } catch (error) {
+    error_text.trace_swallowed("run_event_setup.append_stage", error);
+  }
+}
+function emit_in(repository, text, at) {
+  append_stage(() => run_event_stream.target_of(repository), text, at);
+}
+function emit_to(target, text, at) {
+  append_stage(() => target, text, at);
+}
+function is_stage(event, prefix) {
+  return event.kind === run_event_stream.EVENT_KIND.SETUP && event.text.startsWith(prefix);
+}
+function first_lane_span(start, later) {
+  const next_start = later.findIndex((event) => is_stage(event, STAGE.STARTING));
+  const session = next_start === -1 ? later : later.slice(0, next_start);
+  const opening = session.find((event) => is_stage(event, OPENING));
+  return {
+    from_ms: Date.parse(start.at),
+    end_ms: opening === void 0 ? void 0 : Date.parse(opening.at)
+  };
+}
+function first_lane_spans(events) {
+  return events.flatMap(
+    (event, index) => is_stage(event, STAGE.STARTING) ? [first_lane_span(event, events.slice(index + 1))] : []
+  );
+}
+function first_lane_ms(events) {
+  const span = first_lane_spans(events).at(-1);
+  return span?.end_ms === void 0 ? void 0 : span.end_ms - span.from_ms;
+}
+var run_event_setup = {
+  LANE_STAGE,
+  STAGE,
+  dispatching,
+  emit,
+  emit_in,
+  emit_to,
+  first_lane_ms,
+  first_lane_spans,
+  installing,
+  is_stage,
+  no_child,
+  opening_lane
+};
+
+export {
+  run_event_setup
+};

package/dist/commands/chunk-ON4IKRGS.js

@@ -0,0 +1,469 @@
+import {
+  review_stop_log
+} from "./chunk-GGWXF7RJ.js";
+import {
+  agent_safe_text
+} from "./chunk-3LZXX5GL.js";
+import {
+  shell_quote
+} from "./chunk-W2IA2LV3.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-reap.ts
+import { execFileSync } from "node:child_process";
+
+// scripts/run/ship/run-ship-next.ts
+var { STAGE } = run_ship_stage;
+var COMMAND = {
+  LOG: "pnpm josh ship --log",
+  DETACH: "pnpm josh ship --detach",
+  DETACH_REVIEW: "pnpm josh ship --detach --review"
+};
+function resume_of(args) {
+  const cites = args.cites.flatMap((cite) => ["--cite", cite]);
+  return {
+    title: args.title,
+    flags: [...args.notify, ...args.body, ...cites],
+    is_review: args.is_review,
+    unpinned_ok: args.unpinned_ok
+  };
+}
+function ship_command(command, resume, review_flags = []) {
+  const words = [...review_flags, ...resume.flags, resume.title].map(
+    (token) => shell_quote.word(token)
+  );
+  return [command, ...words].join(" ");
+}
+function review_command(resume) {
+  return ship_command(COMMAND.DETACH_REVIEW, resume, resume.unpinned_ok);
+}
+function detach_again(resume) {
+  return `leave the fix uncommitted and run \`${ship_command(COMMAND.DETACH, resume)}\`.`;
+}
+function detach_as_started(resume) {
+  const command = resume.is_review ? review_command(resume) : ship_command(COMMAND.DETACH, resume);
+  return `leave the fix uncommitted and run \`${command}\`.`;
+}
+var AFTER_FIX = {
+  [STAGE.PREFLIGHT]: detach_as_started,
+  [STAGE.REVIEW]: detach_as_started,
+  [STAGE.GATE]: detach_as_started,
+  [STAGE.SYNC]: detach_as_started,
+  [STAGE.COMMIT]: detach_as_started,
+  [STAGE.ROUND_TWO]: detach_again,
+  [STAGE.FOLLOWUP]: detach_again,
+  [STAGE.REPORT]: detach_again
+};
+function detach_review_again(resume) {
+  return `leave the fix uncommitted and run \`${review_command(resume)}\` \u2014 the review read the issue before its update, so the supervisor reviews round 1 again.`;
+}
+function after_fix(stage, resume) {
+  return resume.is_review_stale === true ? detach_review_again(resume) : AFTER_FIX[stage](resume);
+}
+function conflict_step(conflicts) {
+  return `Resolve the conflict with origin/main in ${conflicts.join(", ")} (the merge is left in progress: remove the conflict markers in those files), then`;
+}
+function fix_step(issue, stage, is_excerpted) {
+  if (is_excerpted) return `Fix the ${stage} failure shown in the output below`;
+  return `Read the stopped report with \`${COMMAND.LOG} ${issue}\`, fix the ${stage} failure`;
+}
+function next_step(issue, stage, resume, is_excerpted = false) {
+  const conflicts = resume.conflicts ?? [];
+  if (conflicts.length > 0) return `${conflict_step(conflicts)} ${after_fix(stage, resume)}`;
+  return `${fix_step(issue, stage, is_excerpted)}, then ${after_fix(stage, resume)}`;
+}
+var run_ship_next = { COMMAND, next_step, resume_of };
+
+// scripts/run/ship/run-ship-stop-context.ts
+import { stripVTControlCharacters } from "node:util";
+
+// scripts/review/review-prior-findings.ts
+var PRIOR_LIMIT = 5;
+var ENTRY_LENGTH_LIMIT = 400;
+var LINE_SUFFIX = /:\d.*$/u;
+var KEY_SEPARATOR = " \u2014 ";
+var LINE_BREAKS = /[\n\r]+/gu;
+function file_of(location) {
+  return location.replace(LINE_SUFFIX, "");
+}
+function key_of(finding) {
+  return `${finding.location}${KEY_SEPARATOR}${finding.sentence}`;
+}
+function entry_text(line) {
+  const disposition = line.fixed === true ? "fixed in place" : "stopped";
+  const text = `${key_of(line)} (${line.kind}, ${disposition} in the ${line.stage} stage)`;
+  return agent_safe_text.printable(text.replaceAll(LINE_BREAKS, " ")).slice(0, ENTRY_LENGTH_LIMIT);
+}
+function latest(issue, is_kept, log_path) {
+  return review_stop_log.read(log_path).filter((line) => String(line.issue) === issue && is_kept(line)).slice(-PRIOR_LIMIT).map((line) => entry_text(line));
+}
+function on_files(issue, current, log_path) {
+  const files = new Set(current.map((finding) => file_of(finding.location)));
+  const own = new Set(current.map((finding) => key_of(finding)));
+  return latest(
+    issue,
+    (line) => files.has(file_of(line.location)) && !own.has(key_of(line)),
+    log_path
+  );
+}
+function fix_lines(entries) {
+  if (entries === void 0 || entries.length === 0) return [];
+  return [
+    "Earlier review findings on the same files in this lane \u2014 confirm the fix still meets each before shipping again:",
+    ...entries.map((entry) => `- ${entry}`)
+  ];
+}
+function prompt_clauses(issue, log_path) {
+  const entries = latest(issue, () => true, log_path);
+  if (entries.length === 0) return [];
+  return [
+    `Earlier review rounds in this lane recorded these findings: ${entries.join("; ")}.`,
+    "Check that the change still meets each of them, and report a change that breaks one as a finding."
+  ];
+}
+var review_prior_findings = {
+  ENTRY_LENGTH_LIMIT,
+  PRIOR_LIMIT,
+  fix_lines,
+  latest,
+  on_files,
+  prompt_clauses
+};
+
+// scripts/run/ship/run-ship-stop-context.ts
+import { z } from "zod";
+var EXCERPT_LINE_LIMIT = 40;
+var EXCERPT_LINE_WIDTH = 240;
+var CHANGED_PATH_LIMIT = 30;
+var OUTPUT_PREFIX = "josh-ship-stop-";
+var OUTPUT_SUFFIX = ".log";
+var KEY_SEPARATOR2 = "-";
+var LINE_BREAK = "\n";
+var CARRIAGE_RETURN = "\r";
+var omitted_schema = z.object({ path: z.string().optional(), last_line: z.number().int() }).strict();
+var stop_context_schema = z.object({
+  excerpt: z.array(z.string()).readonly(),
+  omitted: omitted_schema.optional(),
+  changed: z.array(z.string()).readonly().optional(),
+  more_changed: z.number().int(),
+  prior: z.array(z.string()).readonly().optional()
+}).strict();
+function shown_frame(line) {
+  return line.trimEnd().split(CARRIAGE_RETURN).at(-1) ?? "";
+}
+function output_lines(output) {
+  return stripVTControlCharacters(output).trimEnd().split(LINE_BREAK).map((line) => agent_safe_text.printable(shown_frame(line)));
+}
+async function keep_full_output(issue, output) {
+  const repository = await git_common_directory.read_repository();
+  if (repository === void 0) return void 0;
+  const target = stamp_file.stamp_path(
+    `${OUTPUT_PREFIX}${issue}${KEY_SEPARATOR2}`,
+    repository,
+    OUTPUT_SUFFIX
+  );
+  try {
+    return stamp_file.replace_text_stamp(target, output);
+  } catch {
+    return void 0;
+  }
+}
+async function omitted_range(issue, lines) {
+  const path2 = await keep_full_output(issue, lines.join(LINE_BREAK));
+  const last_line = lines.length - EXCERPT_LINE_LIMIT;
+  return path2 === void 0 ? { last_line } : { path: path2, last_line };
+}
+function clipped(lines) {
+  return lines.map((line) => line.slice(0, EXCERPT_LINE_WIDTH));
+}
+async function excerpt_of(issue, output) {
+  const lines = output.trim() === "" ? [] : output_lines(output);
+  if (lines.length <= EXCERPT_LINE_LIMIT) return { excerpt: clipped(lines) };
+  return {
+    excerpt: clipped(lines.slice(-EXCERPT_LINE_LIMIT)),
+    omitted: await omitted_range(issue, lines)
+  };
+}
+async function read_paths() {
+  try {
+    return await changed_paths.read_changed_paths(false);
+  } catch {
+    return void 0;
+  }
+}
+async function changed_of() {
+  const paths = await read_paths();
+  if (paths === void 0) return { more_changed: 0 };
+  return {
+    changed: paths.slice(0, CHANGED_PATH_LIMIT),
+    more_changed: Math.max(0, paths.length - CHANGED_PATH_LIMIT)
+  };
+}
+async function build(issue, output, findings = []) {
+  const prior = review_prior_findings.on_files(issue, findings);
+  return {
+    ...await excerpt_of(issue, output),
+    ...await changed_of(),
+    ...prior.length > 0 && { prior }
+  };
+}
+function has_excerpt(context) {
+  return context !== void 0 && context.excerpt.length > 0;
+}
+function excerpt_heading(issue, omitted, shown) {
+  if (omitted === void 0) return "The failed stage output:";
+  const source = omitted.path ?? `the stopped report (\`${run_ship_next.COMMAND.LOG} ${issue}\`)`;
+  const range = `lines 1-${String(omitted.last_line)} are in ${source}`;
+  return `The failed stage output (its last ${String(shown)} lines; ${range}):`;
+}
+function with_dropped(omitted, dropped) {
+  if (dropped === 0) return omitted;
+  return { ...omitted, last_line: (omitted?.last_line ?? 0) + dropped };
+}
+function excerpt_block(issue, context, changed, dropped) {
+  const shown = context.excerpt.slice(dropped);
+  const heading = excerpt_heading(issue, with_dropped(context.omitted, dropped), shown.length);
+  return [heading, ...shown, changed].join(LINE_BREAK);
+}
+function changed_text(context) {
+  if (context.changed === void 0) return "The changed files could not be read from git.";
+  if (context.changed.length === 0) return "No files changed against the default branch.";
+  const more = context.more_changed > 0 ? ` (and ${String(context.more_changed)} more)` : "";
+  return `Changed files on the branch: ${context.changed.join(", ")}${more}.`;
+}
+function trailer_text(context) {
+  return [changed_text(context), ...review_prior_findings.fix_lines(context.prior)].join(LINE_BREAK);
+}
+function fitted_block(issue, context, budget) {
+  const changed = trailer_text(context);
+  if (!has_excerpt(context)) return changed;
+  let dropped = 0;
+  let block = excerpt_block(issue, context, changed, dropped);
+  while (block.length > budget && dropped < context.excerpt.length - 1) {
+    dropped += 1;
+    block = excerpt_block(issue, context, changed, dropped);
+  }
+  return block;
+}
+function has_prior(context) {
+  return context.prior !== void 0 && context.prior.length > 0;
+}
+function describe(issue, context, budget = agent_safe_text.MAX_VALUE_LENGTH) {
+  let fitted = context;
+  let block = fitted_block(issue, fitted, budget);
+  while (block.length > budget && has_prior(fitted)) {
+    fitted = { ...fitted, prior: fitted.prior?.slice(1) };
+    block = fitted_block(issue, fitted, budget);
+  }
+  return block;
+}
+var run_ship_stop_context = {
+  CHANGED_PATH_LIMIT,
+  EXCERPT_LINE_LIMIT,
+  build,
+  describe,
+  has_excerpt,
+  stop_context_schema
+};
+
+// scripts/lane/lane-child-invocation.ts
+var CHILD_INVOCATION = "fullrun";
+var LINE_BREAK2 = "\n";
+var REVIEW_INVOCATION = "the reviewer of lane";
+var RESUME_GUIDE = ".claude/skills/workflow-commands/pre-gate-cut.md";
+var SHIP_PROCESS = String.raw`(josh(\.[jt]s)? ship|run-ship-cli\.ts)`;
+function child_invocation(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `${CHILD_INVOCATION} ${issue_cite.plain_for("program", issue)}`;
+}
+function process_pattern(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `(${CHILD_INVOCATION}|${REVIEW_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain_for("program", issue)}$`;
+}
+function ship_pattern(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `${SHIP_PROCESS} .* ${issue_cite.plain_for("program", issue)}$`;
+}
+function review_invocation(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `${REVIEW_INVOCATION} ${issue_cite.plain_for("program", issue)}`;
+}
+function resume_invocation(issue) {
+  const preamble = `Resuming the lane child for issue ${issue_cite.plain_for("program", issue)} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:entry ${issue}\` once before anything else; it checks the carried cut and completes the entry on \`fresh\`. Follow its resume verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Continue this`;
+  return `${preamble} ${child_invocation(issue)}`;
+}
+function outage_resume_invocation(issue) {
+  const preamble = `Resuming the lane child for issue ${issue_cite.plain_for("program", issue)} after an API disconnection \u2014 your session was restored with its full context, so do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Continue the run from where it stopped: run \`pnpm josh run:step ${issue}\` to find the next action, redoing only the last step if it did not complete.`;
+  return `${preamble} ${child_invocation(issue)}`;
+}
+function known_stop_lines(issue, stop, frame) {
+  const { context } = stop;
+  const is_excerpted = run_ship_stop_context.has_excerpt(context);
+  const next = run_ship_next.next_step(issue, stop.stage, stop, is_excerpted);
+  if (context === void 0) return [next];
+  const fixed = [...frame, next].join(LINE_BREAK2).length + LINE_BREAK2.length;
+  const budget = agent_safe_text.MAX_VALUE_LENGTH - fixed;
+  return [next, run_ship_stop_context.describe(issue, context, budget)];
+}
+function ship_stop_invocation(issue, stop) {
+  const opening = `Resuming the lane child for issue ${issue_cite.plain_for("program", issue)} after its detached ship supervisor stopped at a failed stage \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md).`;
+  const closing = `Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue)}`;
+  const middle = stop === void 0 ? [
+    `Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.`
+  ] : known_stop_lines(issue, stop, [opening, closing]);
+  return [opening, ...middle, closing].join(LINE_BREAK2);
+}
+function ship_stop_note(issue, stop) {
+  return known_stop_lines(issue, stop, []).join(LINE_BREAK2);
+}
+var lane_child_invocation = {
+  child_invocation,
+  outage_resume_invocation,
+  process_pattern,
+  resume_invocation,
+  review_invocation,
+  ship_pattern,
+  ship_stop_invocation,
+  ship_stop_note
+};
+
+// scripts/lane/process-tools.ts
+import path from "node:path";
+var NOT_FOUND_CODE = "ENOENT";
+var PACKAGE_HINT = "install the package that provides it (procps on Debian/Ubuntu: `apt-get install procps`)";
+function is_not_found(error) {
+  return error instanceof Error && "code" in error && error.code === NOT_FOUND_CODE;
+}
+function missing_notice(command) {
+  return `\`${path.basename(command)}\` is not installed \u2014 kit's lane commands read processes with ps and pgrep; ${PACKAGE_HINT}`;
+}
+function throw_if_missing(command, error) {
+  if (is_not_found(error)) throw new Error(missing_notice(command), { cause: error });
+}
+var process_tools = { missing_notice, throw_if_missing };
+
+// scripts/lane/lane-reap.ts
+var PGREP_COMMAND = "pgrep";
+var MATCH_FULL_COMMAND_LINE = "-f";
+var CHILDREN_OF_FLAG = "-P";
+var PS_COMMAND = "/bin/ps";
+var PARENT_FORMAT = ["-o", "ppid=", "-p"];
+var TERMINATE_SIGNAL = "SIGTERM";
+var CONTINUE_SIGNAL = "SIGCONT";
+var LOWEST_CHILD_PID = 2;
+function parse_pids(printed) {
+  return printed.split("\n").map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid >= LOWEST_CHILD_PID);
+}
+function run_probe(command, args) {
+  try {
+    return execFileSync(command, [...args], {
+      encoding: "utf8",
+      timeout: PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch (error) {
+    process_tools.throw_if_missing(command, error);
+    return "";
+  }
+}
+function parent_of(pid) {
+  return parse_pids(run_probe(PS_COMMAND, [...PARENT_FORMAT, String(pid)]))[0];
+}
+function send(pid, name) {
+  try {
+    process.kill(pid, name);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function terminate(pid) {
+  if (!send(pid, TERMINATE_SIGNAL)) return false;
+  send(pid, CONTINUE_SIGNAL);
+  return true;
+}
+var SYSTEM_PROBES = {
+  matching: (pattern) => parse_pids(run_probe(PGREP_COMMAND, [MATCH_FULL_COMMAND_LINE, pattern])),
+  children_of: (pid) => parse_pids(run_probe(PGREP_COMMAND, [CHILDREN_OF_FLAG, String(pid)])),
+  parent_of,
+  terminate
+};
+function ancestry_of(pid, probes = SYSTEM_PROBES) {
+  const ancestry = /* @__PURE__ */ new Set([pid]);
+  let current = probes.parent_of(pid);
+  while (current !== void 0 && !ancestry.has(current)) {
+    ancestry.add(current);
+    current = probes.parent_of(current);
+  }
+  return ancestry;
+}
+function own_ancestry(probes = SYSTEM_PROBES) {
+  return ancestry_of(process.pid, probes);
+}
+function tree_of(roots, probes) {
+  const tree = [];
+  const pending = [...roots];
+  let next = pending.shift();
+  while (next !== void 0) {
+    if (!tree.includes(next)) {
+      tree.push(next);
+      pending.push(...probes.children_of(next));
+    }
+    next = pending.shift();
+  }
+  return tree;
+}
+function roots_of(issue, own, probes) {
+  const pattern = lane_child_invocation.process_pattern(issue);
+  return probes.matching(pattern).filter((pid) => !own.has(pid));
+}
+function lane_tree(issue, probes = SYSTEM_PROBES) {
+  const own = own_ancestry(probes);
+  return tree_of(roots_of(issue, own, probes), probes).filter((pid) => !own.has(pid));
+}
+function reap_child(lane, probes = SYSTEM_PROBES) {
+  return lane_tree(lane.issue, probes).filter((pid) => probes.terminate(pid));
+}
+function is_child_running(issue, probes = SYSTEM_PROBES) {
+  return roots_of(issue, own_ancestry(probes), probes).length > 0;
+}
+var lane_reap = {
+  ancestry_of,
+  is_child_running,
+  lane_tree,
+  own_ancestry,
+  parse_pids,
+  PS_COMMAND,
+  reap_child,
+  run_probe,
+  SYSTEM_PROBES
+};
+
+export {
+  run_ship_next,
+  review_prior_findings,
+  run_ship_stop_context,
+  lane_child_invocation,
+  process_tools,
+  lane_reap
+};

package/dist/commands/chunk-OT74RSQO.js

@@ -0,0 +1,82 @@
+import {
+  run_board_closed
+} from "./chunk-DVCMQMRN.js";
+import {
+  lane_withdraw
+} from "./chunk-P43GWYR6.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/lane/lane-withdraw-closed.ts
+var SWEEP_REASON = "its issue was closed as not planned while the lane was still open";
+function is_not_planned(read) {
+  return read !== void 0 && read.is_not_planned && !read.is_merged;
+}
+async function closed_lanes() {
+  const listed = await lane_registry.list_lanes();
+  const lanes = listed.filter((lane) => !lane.is_stranded);
+  const { closed } = await run_board_closed.read_all(lanes.map((lane) => Number(lane.issue)));
+  return lanes.filter((lane) => is_not_planned(closed.get(Number(lane.issue))));
+}
+async function has_unpushed(branch) {
+  try {
+    return await git_command.commit_count_unpushed(branch) > 0;
+  } catch (error) {
+    error_text.trace_swallowed("lane_withdraw_closed.has_unpushed", error);
+    return true;
+  }
+}
+function kept_note(issue, by) {
+  const settled = by === "yield" ? "gave its lane back" : "is closed without a merge";
+  return `${session_cite.issue(issue)} ${settled}, but its branch has commits on no remote, so its lane is kept \u2014 run \`pnpm josh lane:withdraw ${issue}\` by hand.`;
+}
+async function withdraw_lane(lane, reason, by) {
+  if (await has_unpushed(lane.branch)) return { note: kept_note(lane.issue, by), is_retry: false };
+  const outcome = await lane_withdraw.withdraw(lane.issue, reason, by);
+  return {
+    note: lane_withdraw.describe(outcome, lane.issue),
+    is_retry: outcome.kind === "unreadable"
+  };
+}
+async function sweep_lane(lane, events) {
+  if (run_event_scope.is_withdrawn(events, lane.issue)) return void 0;
+  const { note } = await withdraw_lane(lane, SWEEP_REASON, "supervisor");
+  return note;
+}
+async function try_sweep_lane(lane, events) {
+  try {
+    return await sweep_lane(lane, events);
+  } catch (error) {
+    error_text.trace_swallowed("lane_withdraw_closed.sweep_lane", error);
+    return `${session_cite.issue(lane.issue)} could not be withdrawn (${error_text.message_of(error)}); the next pass tries again.`;
+  }
+}
+async function withdraw_closed() {
+  const lanes = await closed_lanes();
+  const events = await run_event_stream_emit.current_events();
+  const notes = [];
+  for (const lane of lanes) {
+    const note = await try_sweep_lane(lane, events);
+    if (note !== void 0) notes.push(note);
+  }
+  return notes;
+}
+var lane_withdraw_closed = { SWEEP_REASON, withdraw_closed, withdraw_lane };
+
+export {
+  lane_withdraw_closed
+};