@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-UJGNYPMD.js

@@ -0,0 +1,716 @@
+import {
+  run_merge_token
+} from "./chunk-TXRWAL63.js";
+import {
+  backlog_named
+} from "./chunk-ZYGOZT4J.js";
+import {
+  lane_parked
+} from "./chunk-BLRXHK2V.js";
+import {
+  backlog_hold_codes
+} from "./chunk-MXPCEZL5.js";
+import {
+  backlog_drive_restore
+} from "./chunk-SQZZHK6X.js";
+import {
+  run_event_setup
+} from "./chunk-OKN63ZH5.js";
+import {
+  issue_body_keys
+} from "./chunk-KXK2A2HB.js";
+import {
+  machine_capacity
+} from "./chunk-XDR2BRDL.js";
+import {
+  figure_format
+} from "./chunk-7EAYFMDN.js";
+import {
+  ALREADY_DONE_LABEL,
+  NEEDS_DECISION_LABEL,
+  NEEDS_HUMAN_MERGE_LABEL,
+  NEEDS_HUMAN_REVIEW_LABEL,
+  RUN_STALLED_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  run_carry,
+  run_carry_added,
+  run_invocation
+} from "./chunk-DS53UUDH.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND,
+  SECONDS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/backlog/backlog-drive-named.ts
+var { MERGE_TOKEN } = run_merge_token;
+var NO_RETRIES = 0;
+var TERMINAL_OUTCOMES = /* @__PURE__ */ new Set([
+  "merged",
+  "parked",
+  "human-review",
+  "split",
+  "withdrawn"
+]);
+function is_declared(carry, issue) {
+  return run_invocation.issue_numbers(carry.invocation)?.includes(Number(issue)) === true;
+}
+function is_held(carry, in_flight, issue) {
+  return !in_flight.includes(String(issue)) || is_declared(carry, String(issue));
+}
+function next_of(carry, in_flight) {
+  const remaining = run_carry.remaining_of(carry) ?? [];
+  return remaining.find((issue) => is_held(carry, in_flight, issue));
+}
+function held_after(carry, in_flight, issue) {
+  const next = next_of(carry, in_flight);
+  if (next === void 0 || in_flight.includes(String(issue))) return void 0;
+  const declared = (run_carry.remaining_of(carry) ?? []).filter(
+    (number) => is_declared(carry, String(number))
+  );
+  const index = declared.indexOf(issue);
+  return index > declared.indexOf(next) ? declared[index - 1] : void 0;
+}
+function only_end(state) {
+  return state.in_flight.length > 0 ? { verdict: "wait", issues: [], retries: NO_RETRIES } : { verdict: "stop", issues: [], retries: NO_RETRIES, reason: "only", is_finish: true };
+}
+function offer(carry, state, is_only) {
+  const next = next_of(carry, state.in_flight);
+  if (next !== void 0) {
+    const issue = String(next);
+    return state.in_flight.includes(issue) ? { verdict: "wait", issues: [], retries: NO_RETRIES } : { verdict: "run", issues: [issue], retries: NO_RETRIES };
+  }
+  return is_only ? only_end(state) : void 0;
+}
+function is_done(result) {
+  if (TERMINAL_OUTCOMES.has(result.outcome)) {
+    return result.code === 0 && result.token !== MERGE_TOKEN.BUSY;
+  }
+  return result.outcome === "failed" && result.code === 0 && !run_merge_token.is_control_stop(result);
+}
+function can_mark(carry, issue, owner) {
+  const is_named = run_carry.remaining_of(carry)?.includes(Number(issue)) === true;
+  const is_owned = !run_carry.is_count_refused(carry, run_carry.owner_of(Number(owner)));
+  return is_named && is_owned;
+}
+function mark_one(target, issue, owner) {
+  const read = run_carry.read_carry(target);
+  if (read.kind !== "carried" || !can_mark(read.carry, issue, owner)) return false;
+  run_carry.apply_change(target, read.carry, { done: Number(issue) });
+  return true;
+}
+function skipped_of(carry, issue) {
+  if (!is_declared(carry, issue)) return [];
+  const remaining = run_carry.remaining_of({ ...carry, added: void 0 }) ?? [];
+  const named = [
+    { issue: Number(issue), is_epic: false },
+    ...remaining.map((number) => ({ issue: number, is_epic: false }))
+  ];
+  return backlog_named.after_failure(named, Number(issue)).skipped;
+}
+function skip_after_failure(target, issue, owner) {
+  const read = run_carry.read_carry(target);
+  if (read.kind !== "carried") return;
+  for (const number of skipped_of(read.carry, issue)) {
+    if (!mark_one(target, String(number), owner)) return;
+  }
+}
+async function should_skip(issue, outcome) {
+  if (outcome === "failed") return true;
+  if (outcome !== "parked") return false;
+  return await lane_parked.is_parked(issue);
+}
+async function carry_target() {
+  const directory = await run_carry.repository_directory();
+  return directory === void 0 ? void 0 : run_carry.carry_path(directory);
+}
+async function mark_done(issue, result, owner) {
+  if (!is_done(result)) return;
+  const target = await carry_target();
+  if (target === void 0 || !mark_one(target, issue, owner)) return;
+  if (await should_skip(issue, result.outcome)) skip_after_failure(target, issue, owner);
+}
+async function mark_settled(issue, owner) {
+  const target = await carry_target();
+  if (target !== void 0) mark_one(target, issue, owner);
+}
+async function reconcile(carry, events, owner) {
+  const named = run_carry.remaining_of(carry) ?? [];
+  const settled = backlog_drive_restore.settled_issues(events);
+  const parked = backlog_drive_restore.parked_issues(events);
+  const merged = new Set(carry.merged_issues);
+  const completed = named.filter((issue) => settled.has(issue) || merged.has(issue));
+  for (const issue of completed) {
+    const outcome = parked.has(issue) ? "parked" : "merged";
+    await mark_done(String(issue), { outcome, code: 0, token: "none", is_offer: true }, owner);
+  }
+}
+function named_issues(carry) {
+  return run_carry_added.ordered(run_invocation.issue_numbers(carry.invocation) ?? [], carry.added);
+}
+function own_carried(carry, dispatched, is_only) {
+  if (!is_only) return dispatched;
+  const named = named_issues(carry);
+  return dispatched.filter((issue) => named.includes(Number(issue)));
+}
+var backlog_drive_named = {
+  is_declared,
+  next_of,
+  offer,
+  held_after,
+  mark_done,
+  mark_settled,
+  named_issues,
+  own_carried,
+  reconcile
+};
+
+// scripts/run/board/run-board-labels.ts
+import { WriteStream } from "node:tty";
+import { styleText } from "node:util";
+import cli_spinners from "cli-spinners";
+
+// scripts/run/board/run-board-length.ts
+var MINUTES_PER_HOUR = 60;
+var SPAN_UNITS = { hours: "\xB0", minutes: "\u2032", seconds: "\u2033" };
+var ZERO_SECONDS = `00${SPAN_UNITS.seconds}`;
+var { two_digits } = figure_format;
+function span_fields(ms) {
+  const seconds = Math.floor(Math.max(0, ms) / MS_PER_SECOND);
+  const minutes = Math.floor(seconds / SECONDS_PER_MINUTE);
+  const hours = Math.floor(minutes / MINUTES_PER_HOUR);
+  return [
+    { value: hours, unit: SPAN_UNITS.hours },
+    { value: minutes % MINUTES_PER_HOUR, unit: SPAN_UNITS.minutes },
+    { value: seconds % SECONDS_PER_MINUTE, unit: SPAN_UNITS.seconds }
+  ];
+}
+function span_of(ms) {
+  const fields = span_fields(ms);
+  const lead = fields.findIndex((field, index) => field.value > 0 || index === fields.length - 1);
+  const [first, ...rest] = fields.slice(lead);
+  const head = first === void 0 ? "" : `${String(first.value)}${first.unit}`;
+  return head + rest.map((field) => `${two_digits(field.value)}${field.unit}`).join("");
+}
+function minute_span_of(ms) {
+  const minutes = Math.max(1, Math.ceil(ms / MS_PER_MINUTE));
+  return span_of(minutes * MS_PER_MINUTE).slice(0, -ZERO_SECONDS.length);
+}
+var run_board_length = { minute_span_of, span_of };
+
+// scripts/run/board/run-board-labels.ts
+var BAR_WIDTH = 10;
+var BAR_DONE = "\u25A0";
+var BAR_LEFT = "\u2500";
+var BAR_DONE_COLOR = "cyan";
+var BAR_LEFT_COLOR = "dim";
+var SPINNER_FRAMES = cli_spinners.dots.frames;
+var SPINNER_INTERVAL_MS = cli_spinners.dots.interval;
+var RGB_COLOR_DEPTH = 24;
+var ESC = "\x1B";
+var DEFAULT_FOREGROUND = `${ESC}[39m`;
+var WORDS = {
+  no_run: "no run",
+  plan: "plan",
+  // The reads off this machine — the run's stream, its lanes and the gauges — that last failed.
+  read: "read",
+  merged: "merged",
+  parked: "parked",
+  done: "done",
+  already_done: "already done",
+  withdrawn: "withdrawn",
+  in_progress: "running",
+  stopped: "stopped",
+  paused: "paused",
+  earlier: "earlier run's lane, not counted",
+  unknown: "lane state unknown",
+  waiting: "waiting",
+  queued: "queued",
+  not_before: "not before",
+  decision: "decision",
+  waits: "waits on",
+  // What a waiting row waits on, where the legend names its icon.
+  opening: "opening lane",
+  installing: "installing",
+  dispatching: "dispatching",
+  lane: "free lane",
+  path: "path held",
+  named: "named order",
+  held: "held by triage",
+  headroom: "memory headroom",
+  usage_limit: "usage limit",
+  untriaged: "untriaged",
+  solo: "runs alone",
+  solo_ahead: "behind solo",
+  solo_running: "solo running",
+  // A blocker this run will not finish, which a person has to move (joshuafolkken/kit#4292).
+  on_human: "needs a person",
+  human_merge: "human merge",
+  // A lane held back by the machine-wide core budget, and why.
+  held_check: "held",
+  memory: "waits for memory",
+  cores: "waits for CPU",
+  // How long a lane has run, which the lanes rule's ⏰ stands over.
+  elapsed: "elapsed",
+  investigate: "investigate",
+  implement: "implement",
+  ship: "ship",
+  review: "review",
+  gate: "gate",
+  sync: "sync",
+  commit: "commit",
+  round_two: "round-2",
+  followup: "followup",
+  report: "report",
+  failed: "failed",
+  notes: "findings",
+  more: "more",
+  filed: "filed",
+  filed_run: "filed this run",
+  breaking: "breaking",
+  feature: "feature",
+  fix: "fix",
+  park: "park",
+  note: "note",
+  found_during: " (found during {n})",
+  overrun: "overrun investigation",
+  // What the run is doing now, where no stage of its own says it.
+  watching: "watching",
+  pool_empty: "pool empty",
+  on_person: "waiting on a person",
+  operation: "operation",
+  ended: "ended",
+  estimate: "estimated finish",
+  // The session a stopped run waits in, and what closing the board leaves.
+  resume: "stopped \u2014 resume with",
+  keeps_running: "Closing this screen leaves the run going \xB7 reopen with `pnpm josh backlogrun`"
+};
+var STATE_ICONS = {
+  running: "\u{1F504}",
+  merged: "\u2705",
+  parked: "\u{1F4A4}",
+  done: "\u{1F3C1}",
+  already_done: "\u23E9",
+  waiting: "\u23F3",
+  human: "\u{1F64B}",
+  stopped: "\u{1F6D1}",
+  paused: "\u{1F9CA}",
+  withdrawn: "\u{1F6AB}",
+  unknown: "\u2754"
+};
+var WAITS_ICON = "\u{1F517}";
+var NOT_BEFORE_ICON = "\u{1F4C5}";
+var LANES_ICON = "\u{1F9F5}";
+var PHASE_ICONS = {
+  investigate: "\u{1F50D}",
+  plan: "\u{1F4DD}",
+  implement: "\u{1F528}",
+  ship: "\u{1F6A2}",
+  review: "\u{1F440}",
+  gate: "\u{1F6A6}",
+  sync: "\u{1F500}",
+  commit: "\u{1F4E6}",
+  round_two: "\u{1F502}",
+  followup: "\u2693",
+  report: "\u{1F4E3}",
+  failed: "\u{1F4A5}"
+};
+var PHASE_WORDS = {
+  investigate: "investigate",
+  plan: "plan",
+  implement: "implement",
+  ship: "ship",
+  review: "review",
+  gate: "gate",
+  sync: "sync",
+  commit: "commit",
+  round_two: "round_two",
+  followup: "followup",
+  report: "report",
+  failed: "failed"
+};
+var NOTES_ICON = "\u{1F4CC}";
+var FILED_RUN_MARK = "\u271A";
+var OVERRUN_MARK = PHASE_ICONS.investigate;
+var NOTE_ICONS = {
+  filed: "\u{1F195}",
+  park: STATE_ICONS.parked,
+  note: "\u{1F4AC}"
+};
+var FILED_KIND_ICONS = {
+  "breaking-change": "\u{1F9E8}",
+  bug: "\u{1F41B}",
+  enhancement: "\u2728"
+};
+var KIND_BLANK = "  ";
+var KIND_WORDS = {
+  "breaking-change": "breaking",
+  enhancement: "feature",
+  bug: "fix"
+};
+var HEADER_ICONS = {
+  cpu: "\u{1F4AA}",
+  memory: "\u{1F9E0}",
+  swap: "\u{1F4BE}",
+  ended: "\u{1F51A}",
+  loading: "\u23F3",
+  elapsed: "\u23F0",
+  heartbeat: "\u{1F493}",
+  // A failed plan read: ❗ rather than ⚠, a text symbol drawn two columns wide over the blank after it.
+  warning: "\u2757",
+  // The estimated finish: 🎯 rather than 🏁, a done row's state icon, so the legend names each once
+  // (joshuafolkken/kit#4538).
+  estimate: "\u{1F3AF}"
+};
+var NOW_ICONS = { operation: "\u{1F527}", watching: "\u{1F52D}", ended: HEADER_ICONS.ended };
+var { STAGE, LANE_STAGE } = run_event_setup;
+var LANE_STAGE_ICONS = { opening: "\u{1F6AA}", installing: "\u{1F4E5}", dispatching: "\u{1F4E4}" };
+var STAGE_ICONS = {
+  [STAGE.STARTING]: "\u{1F680}",
+  [STAGE.PLANNING]: "\u{1F4DD}",
+  [STAGE.HANDING_OFF]: "\u{1F91D}",
+  [STAGE.JUDGING]: "\u{1F914}",
+  [STAGE.SESSION]: "\u{1F4AD}",
+  [STAGE.RETROSPECTIVE]: PHASE_ICONS.investigate,
+  [STAGE.NO_CHILD]: "\u{1F6AB}",
+  [LANE_STAGE.OPENING]: LANE_STAGE_ICONS.opening,
+  [LANE_STAGE.INSTALLING]: LANE_STAGE_ICONS.installing,
+  [LANE_STAGE.DISPATCHING]: LANE_STAGE_ICONS.dispatching
+};
+var WAIT_ICONS = {
+  human_merge: "\u{1F50F}",
+  usage_limit: "\u{1FAAB}",
+  path: "\u{1F4C2}",
+  named: "\u{1F4CB}",
+  held: "\u270B",
+  untriaged: "\u2753",
+  solo: "\u{1F9CD}",
+  solo_ahead: "\u{1F645}",
+  solo_running: "\u{1F512}",
+  lane: LANES_ICON,
+  memory: HEADER_ICONS.memory,
+  blocker: WAITS_ICON,
+  not_before: NOT_BEFORE_ICON
+};
+var WAIT_WORDS = [
+  [WAIT_ICONS.human_merge, "human_merge"],
+  [LANE_STAGE_ICONS.opening, "opening"],
+  [LANE_STAGE_ICONS.installing, "installing"],
+  [LANE_STAGE_ICONS.dispatching, "dispatching"],
+  [WAIT_ICONS.lane, "lane"],
+  [WAIT_ICONS.path, "path"],
+  [WAIT_ICONS.named, "named"],
+  [WAIT_ICONS.held, "held"],
+  [WAIT_ICONS.solo, "solo"],
+  [WAIT_ICONS.solo_ahead, "solo_ahead"],
+  [WAIT_ICONS.solo_running, "solo_running"],
+  [WAIT_ICONS.usage_limit, "usage_limit"],
+  [WAIT_ICONS.memory, "headroom"],
+  [WAIT_ICONS.untriaged, "untriaged"],
+  [WAIT_ICONS.blocker, "waits"],
+  [STATE_ICONS.human, "on_human"],
+  [WAIT_ICONS.not_before, "not_before"]
+];
+var GAUGE_SHADES = {
+  normal: { rgb: "48;209;88", named: "green" },
+  yellow: { rgb: "255;214;10", named: "yellow" },
+  red: { rgb: "255;69;58", named: "red" }
+};
+var { two_digits: two_digits2, clock_of, minute_of } = figure_format;
+var { minute_span_of: minute_span_of2, span_of: span_of2 } = run_board_length;
+function day_minute_of(ms) {
+  const date = new Date(ms);
+  const day = [date.getMonth() + 1, date.getDate()].map((value) => two_digits2(value));
+  return `${day.join("-")} ${minute_of(ms)}`;
+}
+function is_shade(color) {
+  return typeof color === "object" && "rgb" in color;
+}
+function shaded(shade, text) {
+  const named = styleText(shade.named, text);
+  if (named === text || WriteStream.prototype.getColorDepth() < RGB_COLOR_DEPTH) return named;
+  return `${ESC}[38;2;${shade.rgb}m${text}${DEFAULT_FOREGROUND}`;
+}
+function painted(color, text) {
+  if (color === void 0 || text === "") return text;
+  return is_shade(color) ? shaded(color, text) : styleText(color, text);
+}
+function bar_of(done, total, width = BAR_WIDTH, color = BAR_DONE_COLOR) {
+  const filled = total === 0 ? 0 : Math.round(Math.min(done, total) / total * width);
+  return painted(color, BAR_DONE.repeat(filled)) + painted(BAR_LEFT_COLOR, BAR_LEFT.repeat(width - filled));
+}
+function spinner_of(now_ms) {
+  const step = Math.floor(Math.max(0, now_ms) / SPINNER_INTERVAL_MS);
+  return SPINNER_FRAMES[step % SPINNER_FRAMES.length] ?? "";
+}
+var run_board_labels = {
+  FILED_KIND_ICONS,
+  FILED_RUN_MARK,
+  GAUGE_SHADES,
+  HEADER_ICONS,
+  KIND_BLANK,
+  KIND_WORDS,
+  NOTES_ICON,
+  NOTE_ICONS,
+  NOW_ICONS,
+  OVERRUN_MARK,
+  PHASE_ICONS,
+  PHASE_WORDS,
+  SPINNER_INTERVAL_MS,
+  STAGE_ICONS,
+  STATE_ICONS,
+  WAITS_ICON,
+  WORDS,
+  bar_of,
+  LANES_ICON,
+  WAIT_ICONS,
+  WAIT_WORDS,
+  clock_of,
+  day_minute_of,
+  minute_of,
+  minute_span_of: minute_span_of2,
+  painted,
+  span_of: span_of2,
+  spinner_of
+};
+
+// scripts/run/board/run-board-machine.ts
+var { GAUGE_SHADES: GAUGE_SHADES2, HEADER_ICONS: HEADER_ICONS2, bar_of: bar_of2, painted: painted2 } = run_board_labels;
+var PERCENT = 100;
+var PERCENT_WIDTH = "100%".length;
+var RATE_WIDTH = "3.1M/s".length;
+var RATE_DECIMAL_BELOW = 10;
+var GAP = "  ";
+var CPU_YELLOW = 70;
+var CPU_RED = 90;
+var MEMORY_YELLOW = 70;
+var MEMORY_RED = 85;
+var SWAP_FULL_MB_PER_S = 20;
+var SWAP_YELLOW_MB_PER_S = 1;
+var SWAP_RED_MB_PER_S = 10;
+var PRESSURE_NORMAL = 1;
+var PRESSURE_WARNING = 2;
+var PRESSURE_CRITICAL = 4;
+var PRESSURE_ALERTS = /* @__PURE__ */ new Map([
+  [PRESSURE_NORMAL, "normal"],
+  [PRESSURE_WARNING, "yellow"],
+  [PRESSURE_CRITICAL, "red"]
+]);
+function percent_text(value) {
+  return `${String(Math.round(value))}%`.padStart(PERCENT_WIDTH);
+}
+function rate_text(value) {
+  const figure = value < RATE_DECIMAL_BELOW ? value.toFixed(1) : String(Math.round(value));
+  return `${figure}M/s`.padStart(RATE_WIDTH);
+}
+var SPECS = {
+  cpu: {
+    icon: HEADER_ICONS2.cpu,
+    normal: GAUGE_SHADES2.normal,
+    full: PERCENT,
+    yellow: CPU_YELLOW,
+    red: CPU_RED,
+    format: percent_text
+  },
+  memory: {
+    icon: HEADER_ICONS2.memory,
+    normal: GAUGE_SHADES2.normal,
+    full: PERCENT,
+    yellow: MEMORY_YELLOW,
+    red: MEMORY_RED,
+    format: percent_text
+  },
+  swap: {
+    icon: HEADER_ICONS2.swap,
+    normal: void 0,
+    full: SWAP_FULL_MB_PER_S,
+    yellow: SWAP_YELLOW_MB_PER_S,
+    red: SWAP_RED_MB_PER_S,
+    format: rate_text
+  }
+};
+function cpu_percent(before, after) {
+  if (before === void 0) return void 0;
+  const share = machine_capacity.busy_share_between(before.sample.cpu, after.sample.cpu);
+  return share === void 0 ? void 0 : share * PERCENT;
+}
+function memory_percent(sample) {
+  const { available_mb } = sample.memory;
+  return available_mb === void 0 ? void 0 : PERCENT - available_mb / sample.total_mb * PERCENT;
+}
+function swap_rate(before, after) {
+  if (before === void 0) return void 0;
+  const swapped = machine_capacity.swapped_between(
+    before.sample.memory.swapped_mb,
+    after.sample.memory.swapped_mb
+  );
+  const seconds = (after.at_ms - before.at_ms) / MS_PER_SECOND;
+  return swapped === void 0 || seconds <= 0 ? void 0 : swapped / seconds;
+}
+function gauges_of(before, after) {
+  return {
+    cpu_percent: cpu_percent(before, after),
+    memory_percent: memory_percent(after.sample),
+    swap_mb_per_s: swap_rate(before, after),
+    memory_pressure: after.sample.memory.pressure_level
+  };
+}
+function threshold_alert(value, spec) {
+  if (value >= spec.red) return "red";
+  return value >= spec.yellow ? "yellow" : "normal";
+}
+function alert_of(spec, value, pressure) {
+  const verdict = pressure === void 0 ? void 0 : PRESSURE_ALERTS.get(pressure);
+  return verdict ?? threshold_alert(value, spec);
+}
+function gauge(spec, reading) {
+  const { value, width } = reading;
+  if (value === void 0) return void 0;
+  const alert = alert_of(spec, value, reading.pressure);
+  const warning = alert === "normal" ? void 0 : GAUGE_SHADES2[alert];
+  const bar = bar_of2(value, spec.full, void 0, warning ?? spec.normal);
+  return `${spec.icon} ${painted2(warning, spec.format(value).padStart(width))} ${bar}`;
+}
+function line_of(gauges, width = 0) {
+  if (gauges === void 0) return void 0;
+  const parts = [
+    gauge(SPECS.cpu, { value: gauges.cpu_percent, width }),
+    gauge(SPECS.memory, { value: gauges.memory_percent, width, pressure: gauges.memory_pressure }),
+    gauge(SPECS.swap, { value: gauges.swap_mb_per_s, width })
+  ].filter((part) => part !== void 0);
+  return parts.length === 0 ? void 0 : parts.join(GAP);
+}
+var run_board_machine = {
+  CPU_YELLOW,
+  GAP,
+  MEMORY_RED,
+  MEMORY_YELLOW,
+  PERCENT_WIDTH,
+  SWAP_RED_MB_PER_S,
+  SWAP_YELLOW_MB_PER_S,
+  gauges_of,
+  line_of,
+  percent_text,
+  rate_text
+};
+
+// scripts/backlog/backlog-drive-memory.ts
+var { MEMORY_RED: MEMORY_RED2, MEMORY_YELLOW: MEMORY_YELLOW2, SWAP_RED_MB_PER_S: SWAP_RED_MB_PER_S2, SWAP_YELLOW_MB_PER_S: SWAP_YELLOW_MB_PER_S2 } = run_board_machine;
+var { PRESSURE_HOLD } = machine_capacity;
+var MIN_RATE_MS = 1e3;
+var HOLD_REASON = backlog_hold_codes.MEMORY_REASON;
+function is_kernel_pressured(gauges) {
+  return (gauges.memory_pressure ?? 0) >= PRESSURE_HOLD;
+}
+function is_stop(gauges) {
+  return is_kernel_pressured(gauges) || (gauges.memory_percent ?? 0) >= MEMORY_RED2 || (gauges.swap_mb_per_s ?? 0) >= SWAP_RED_MB_PER_S2;
+}
+function is_resume(gauges) {
+  return !is_kernel_pressured(gauges) && (gauges.memory_percent ?? 0) < MEMORY_YELLOW2 && (gauges.swap_mb_per_s ?? 0) < SWAP_YELLOW_MB_PER_S2;
+}
+var PRODUCTION = { read: machine_capacity.read_sample, now: Date.now };
+function is_rate_of(last, mark) {
+  return last !== void 0 && mark.at_ms - last.at_ms >= MIN_RATE_MS;
+}
+function rated(memo, mark) {
+  const { last } = memo;
+  const is_rated = is_rate_of(last, mark);
+  if (last === void 0 || is_rated) memo.last = mark;
+  const gauges = run_board_machine.gauges_of(is_rated ? last : void 0, mark);
+  if (is_rated) memo.swap_mb_per_s = gauges.swap_mb_per_s;
+  return { ...gauges, swap_mb_per_s: memo.swap_mb_per_s };
+}
+function gauge2(ports = PRODUCTION) {
+  const memo = { last: void 0, swap_mb_per_s: void 0, is_held: false };
+  return async function memory_held() {
+    const gauges = rated(memo, { sample: await ports.read(), at_ms: ports.now() });
+    memo.is_held = memo.is_held ? !is_resume(gauges) : is_stop(gauges);
+    return memo.is_held;
+  };
+}
+async function held(state, ports) {
+  await ports.hold(HOLD_REASON);
+  return { kind: "continue", state: { ...state, is_memory_held: true } };
+}
+async function is_cleared(state, ports) {
+  return state.is_memory_held === true && !await ports.memory_held();
+}
+var backlog_drive_memory = { HOLD_REASON, gauge: gauge2, held, is_cleared };
+
+// scripts/issue/issue-human-stops.ts
+var UNTRUSTED_AUTHOR_KEY = "untrusted-author";
+var HUMAN_STOPS = [
+  {
+    key: NEEDS_DECISION_LABEL,
+    label: NEEDS_DECISION_LABEL,
+    reason: "A judgement only a person can make; the run parks that issue and continues.",
+    idle_heading: `Waiting on a decision (${NEEDS_DECISION_LABEL}):`
+  },
+  {
+    key: NEEDS_HUMAN_REVIEW_LABEL,
+    label: NEEDS_HUMAN_REVIEW_LABEL,
+    reason: "A person's explicit instruction on the issue; only a person removes it."
+  },
+  {
+    key: NEEDS_HUMAN_MERGE_LABEL,
+    label: NEEDS_HUMAN_MERGE_LABEL,
+    reason: "A PR changing `.github/workflows/**` rewrites its own CI gate; merging it unattended would weaken the gate.",
+    idle_heading: `Waiting on a person to merge (${NEEDS_HUMAN_MERGE_LABEL}):`
+  },
+  {
+    key: ALREADY_DONE_LABEL,
+    label: ALREADY_DONE_LABEL,
+    reason: "The work is already merged but the evidence cites no merged PR or commit on main that `issue:already-done` can check, so a person closes it.",
+    idle_heading: `Waiting on a person to close (${ALREADY_DONE_LABEL}):`
+  },
+  {
+    key: UNTRUSTED_AUTHOR_KEY,
+    reason: "An author without write access is untrusted input, never run unattended.",
+    idle_heading: "Waiting on a person to vouch for the body (author without write access):"
+  },
+  {
+    key: "third-party-write",
+    reason: "A tracker we do not own is never written unattended; the lane drafts it under `## Upstream candidate` and continues."
+  },
+  {
+    key: "dev-engines-edit",
+    reason: "A `devEngines` / overrides edit is Tier C; only that issue parks."
+  },
+  {
+    key: "irreversible-op",
+    reason: "Force push, branch delete and destructive ops are never done; the run takes the reversible way instead."
+  },
+  {
+    key: "unauthenticated",
+    reason: "Only a person can run `/login`; the batch waits without stopping."
+  },
+  {
+    key: "filing-exclusion",
+    reason: `\`release\`, \`breaking-change\`, \`deferred\`, \`epic\` and \`${issue_body_keys.line("judgement", "needed")}\` keep an issue out of the pool by a person's choice (\`issue-auto-ok.ts\`).`
+  }
+];
+var AUTO_RESOLVED_PARK_LABELS = /* @__PURE__ */ new Map([
+  [RUN_STALLED_LABEL, "backlog-drive-stalled-retry.ts"]
+]);
+function labels() {
+  return new Set(HUMAN_STOPS.flatMap((stop) => stop.label ?? []));
+}
+function idle_stops() {
+  return HUMAN_STOPS.filter((stop) => stop.idle_heading !== void 0);
+}
+var issue_human_stops = {
+  AUTO_RESOLVED_PARK_LABELS,
+  HUMAN_STOPS,
+  UNTRUSTED_AUTHOR_KEY,
+  idle_stops,
+  labels
+};
+
+export {
+  run_board_labels,
+  issue_human_stops,
+  run_board_machine,
+  backlog_drive_named,
+  backlog_drive_memory
+};