@joshuafolkken/kit 1.872.0

package/dist/hooks/chunk-XKDOYJGA.js

@@ -0,0 +1,922 @@
+import {
+  lane_child_marker,
+  run_issue_number
+} from "./chunk-IKUMBDJB.js";
+import {
+  stamp_file,
+  time_shell
+} from "./chunk-RORDOD4S.js";
+
+// scripts/git/constants.ts
+import { platform } from "node:os";
+var GIT_COMMAND_UNIX = "/usr/bin/git";
+var PORCELAIN_FLAG = "--porcelain";
+function get_git_command() {
+  if (platform() === "win32") {
+    return String.raw`"C:\Program Files\Git\cmd\git.exe"`;
+  }
+  return GIT_COMMAND_UNIX;
+}
+function get_git_command_for_spawn() {
+  if (platform() === "win32") {
+    return String.raw`C:\Program Files\Git\cmd\git.exe`;
+  }
+  return GIT_COMMAND_UNIX;
+}
+var git_utilities = {
+  get_git_command,
+  get_git_command_for_spawn
+};
+
+// scripts/git/git-push-transport.ts
+import { execa } from "execa";
+
+// scripts/git/git-execa-error.ts
+function get_exit_code(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  if (!("exitCode" in error)) return void 0;
+  const { exitCode: exit_code } = error;
+  return typeof exit_code === "number" ? exit_code : void 0;
+}
+function has_timed_out(error) {
+  if (typeof error !== "object" || error === null || !("timedOut" in error)) return false;
+  return error.timedOut === true;
+}
+function create_spawn_error(command, exit_code) {
+  const exit_code_string = exit_code === void 0 ? "unknown" : String(exit_code);
+  const error_message = `git ${command} exited with code ${exit_code_string}`;
+  return new Error(error_message, { cause: { exit_code: exit_code_string } });
+}
+
+// scripts/git/git-push-transport.ts
+var MS_PER_SECOND = 1e3;
+var PUSH_TIMEOUT_SECONDS = 120;
+var PUSH_TIMEOUT_MS = PUSH_TIMEOUT_SECONDS * MS_PER_SECOND;
+var PUSH_TIMEOUT_LABEL = `${String(PUSH_TIMEOUT_SECONDS)}s`;
+var PUSH_TIMEOUT_MESSAGE = "git push timed out";
+var PUSH_TIMEOUT_EXIT_CODE = "timeout";
+var SSH_KEEPALIVE_OPTIONS = "-o ServerAliveInterval=15 -o ServerAliveCountMax=3";
+var SSH_COMMAND_VARIABLE = "GIT_SSH_COMMAND";
+var SSH_LEGACY_VARIABLE = "GIT_SSH";
+var KEEPALIVE_SSH_COMMAND = `ssh ${SSH_KEEPALIVE_OPTIONS}`;
+var SSH_COMMAND_CONFIG_KEY = "core.sshCommand";
+var PUSH_SUBCOMMAND = "push";
+function to_environment_value(name) {
+  return process.env[name]?.trim() ?? "";
+}
+function to_configured_ssh_command() {
+  const from_command = to_environment_value(SSH_COMMAND_VARIABLE);
+  return from_command === "" ? to_environment_value(SSH_LEGACY_VARIABLE) : from_command;
+}
+async function has_configured_ssh_command() {
+  if (to_configured_ssh_command() !== "") return true;
+  try {
+    const git_command_bin = git_utilities.get_git_command_for_spawn();
+    const { stdout } = await execa(git_command_bin, ["config", "--get", SSH_COMMAND_CONFIG_KEY]);
+    return stdout.trim() !== "";
+  } catch {
+    return false;
+  }
+}
+async function to_push_options() {
+  const should_keep_alive = !await has_configured_ssh_command();
+  return {
+    stdio: "inherit",
+    timeout: PUSH_TIMEOUT_MS,
+    env: should_keep_alive ? { [SSH_COMMAND_VARIABLE]: KEEPALIVE_SSH_COMMAND } : {}
+  };
+}
+async function did_push_time_out(arguments_list) {
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  const options = await to_push_options();
+  try {
+    await execa(git_command_bin, [PUSH_SUBCOMMAND, ...arguments_list], options);
+    return false;
+  } catch (error) {
+    if (has_timed_out(error)) return true;
+    throw create_spawn_error(PUSH_SUBCOMMAND, get_exit_code(error));
+  }
+}
+function to_manual_command(arguments_list) {
+  return ["git", PUSH_SUBCOMMAND, ...arguments_list].join(" ");
+}
+function to_retry_notice(arguments_list) {
+  return `${PUSH_TIMEOUT_MESSAGE} after ${PUSH_TIMEOUT_LABEL} \u2014 retrying once: ${to_manual_command(arguments_list)}`;
+}
+function create_timeout_error(arguments_list) {
+  const message = `${PUSH_TIMEOUT_MESSAGE} twice (${PUSH_TIMEOUT_LABEL} each). Re-run it by hand: ${to_manual_command(arguments_list)}`;
+  return new Error(message, { cause: { exit_code: PUSH_TIMEOUT_EXIT_CODE } });
+}
+async function push(arguments_list) {
+  if (!await did_push_time_out(arguments_list)) return;
+  console.warn(to_retry_notice(arguments_list));
+  if (!await did_push_time_out(arguments_list)) return;
+  throw create_timeout_error(arguments_list);
+}
+var git_push_transport = {
+  push
+};
+
+// scripts/git/git-spawn.ts
+import { execa as execa2 } from "execa";
+async function read(arguments_) {
+  const git_cmd = git_utilities.get_git_command_for_spawn();
+  const { stdout } = await execa2(git_cmd, arguments_);
+  return stdout.trimEnd();
+}
+async function with_output(command, arguments_list) {
+  const git_command_bin = git_utilities.get_git_command_for_spawn();
+  try {
+    await execa2(git_command_bin, [command, ...arguments_list], { stdio: "inherit" });
+  } catch (error) {
+    throw create_spawn_error(command, get_exit_code(error));
+  }
+}
+var git_spawn = {
+  read,
+  with_output
+};
+
+// scripts/git/git-command.ts
+async function branch() {
+  return await git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]);
+}
+async function status() {
+  return await git_spawn.read(["status", PORCELAIN_FLAG, "--untracked-files=normal"]);
+}
+async function repository_root() {
+  return await git_spawn.read(["rev-parse", "--show-toplevel"]);
+}
+async function head_commit() {
+  return await git_spawn.read(["rev-parse", "HEAD"]);
+}
+var GIT_DIRECTORY_ARGUMENTS = [
+  "rev-parse",
+  "--absolute-git-dir",
+  "--path-format=absolute",
+  "--git-common-dir"
+];
+async function git_directories() {
+  const output = await git_spawn.read([...GIT_DIRECTORY_ARGUMENTS]);
+  return output.split("\n").filter((line) => line !== "");
+}
+async function diff_cached(file_path) {
+  return await git_spawn.read(["diff", "--cached", file_path]);
+}
+var REFS_REMOTES_ORIGIN_PREFIX = "refs/remotes/origin/";
+var NAME_ONLY_FLAG = "--name-only";
+var DEFAULT_BRANCH_FALLBACK = "main";
+async function get_default_branch() {
+  try {
+    const output = await git_spawn.read(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+    const trimmed = output.trim();
+    if (trimmed.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) {
+      return trimmed.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
+    }
+  } catch {
+  }
+  return DEFAULT_BRANCH_FALLBACK;
+}
+var MERGE_BASE_COMMAND = "merge-base";
+async function reference_exists(reference) {
+  try {
+    await git_spawn.read(["rev-parse", "--verify", "--quiet", reference]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function default_branch_reference() {
+  const default_branch = await get_default_branch();
+  const remote_reference = `${REFS_REMOTES_ORIGIN_PREFIX}${default_branch}`;
+  return await reference_exists(remote_reference) ? remote_reference : default_branch;
+}
+async function change_base() {
+  const default_branch = await default_branch_reference();
+  try {
+    return await git_spawn.read([MERGE_BASE_COMMAND, default_branch, "HEAD"]);
+  } catch {
+    return default_branch;
+  }
+}
+async function diff_main(file_path) {
+  return await git_spawn.read(["diff", await change_base(), "--", file_path]);
+}
+var NO_PATH_QUOTING = ["-c", "core.quotePath=false"];
+var NO_RELATIVE_PATHS = "--no-relative";
+var NO_RENAME_DETECTION = "--no-renames";
+async function change_base_commit() {
+  return await git_spawn.read(["rev-parse", await change_base()]);
+}
+async function diff_main_names() {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    NAME_ONLY_FLAG,
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION,
+    await change_base(),
+    "--"
+  ]);
+}
+async function diff_cached_names() {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    "--cached",
+    NAME_ONLY_FLAG,
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION
+  ]);
+}
+async function diff_main_numstat() {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "diff",
+    "--numstat",
+    NO_RELATIVE_PATHS,
+    NO_RENAME_DETECTION,
+    await change_base(),
+    "--"
+  ]);
+}
+var WHOLE_TREE_PATHSPEC = ":/";
+async function untracked_names() {
+  return await git_spawn.read([
+    ...NO_PATH_QUOTING,
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "--full-name",
+    WHOLE_TREE_PATHSPEC
+  ]);
+}
+async function fetch_branch(branch_name) {
+  const refspec = `+refs/heads/${branch_name}:refs/remotes/origin/${branch_name}`;
+  return await git_spawn.read(["fetch", "origin", refspec]);
+}
+async function merge_fast_forward(branch_name) {
+  return await git_spawn.read(["merge", "--ff-only", `origin/${branch_name}`]);
+}
+async function merge_branch(branch_name) {
+  await git_spawn.with_output("merge", [`origin/${branch_name}`]);
+}
+async function checkout_b(branch_name) {
+  return await git_spawn.read(["checkout", "-b", branch_name]);
+}
+async function checkout(branch_name) {
+  return await git_spawn.read(["checkout", branch_name]);
+}
+async function commit(message) {
+  await git_spawn.with_output("commit", ["-m", message]);
+}
+async function delete_branch(branch_name) {
+  await git_spawn.read(["branch", "-d", branch_name]);
+}
+async function commit_count_beyond(base, tip) {
+  const range = `${base}..${tip}`;
+  const output = await git_spawn.read(["rev-list", "--count", range]);
+  const parsed = Number(output);
+  if (output.length > 0 && Number.isFinite(parsed)) return parsed;
+  throw new Error(`\`git rev-list --count ${range}\` printed \`${output}\` rather than a count`);
+}
+function is_exit_code_128(cause) {
+  return typeof cause === "object" && cause !== null && "exit_code" in cause && cause.exit_code === "128";
+}
+function is_upstream_not_set_error(error) {
+  if (!(error instanceof Error)) return false;
+  const { cause } = error;
+  return cause !== void 0 && is_exit_code_128(cause);
+}
+async function push_with_upstream(branch_name) {
+  await git_push_transport.push(["--set-upstream", "origin", branch_name]);
+}
+async function push2() {
+  try {
+    await git_push_transport.push([]);
+  } catch (error) {
+    if (is_upstream_not_set_error(error)) {
+      const current_branch = await branch();
+      await push_with_upstream(current_branch);
+      return;
+    }
+    throw error;
+  }
+}
+async function pull_fast_forward() {
+  await git_spawn.with_output("pull", ["--ff-only"]);
+}
+var SHORT_NAME_FORMAT = "--format=%(refname:short)";
+var REMOTES_FLAG = "--remotes";
+async function list_branches(flags, pattern) {
+  try {
+    const output = await git_spawn.read([
+      "branch",
+      "--list",
+      SHORT_NAME_FORMAT,
+      ...flags,
+      pattern
+    ]);
+    return output.split("\n").filter((line) => line.trim() !== "");
+  } catch {
+    return [];
+  }
+}
+async function branch_names(pattern) {
+  return await list_branches([], pattern);
+}
+async function branch_names_remote(pattern) {
+  return await list_branches([REMOTES_FLAG], pattern);
+}
+async function branch_exists(branch_name) {
+  const names = await branch_names(branch_name);
+  return names.length > 0;
+}
+var ALL_PATHS_PATHSPEC = ":/";
+function exclude_pathspec(file_path) {
+  return `:(exclude,top)${file_path}`;
+}
+async function add_tracked(excluded_paths) {
+  const exclusions = excluded_paths.map((file_path) => exclude_pathspec(file_path));
+  await git_spawn.read(["add", "-u", "--", ALL_PATHS_PATHSPEC, ...exclusions]);
+}
+async function add_path(file_path) {
+  await git_spawn.with_output("add", ["--", file_path]);
+}
+var FIRST_PARENT_FLAG = "--first-parent";
+async function log_first_parent(limit, file_path, tip = "HEAD") {
+  const output = await git_spawn.read([
+    "log",
+    FIRST_PARENT_FLAG,
+    "--format=%H",
+    `-n`,
+    String(limit),
+    tip,
+    "--",
+    file_path
+  ]);
+  return output.split("\n").filter((line) => line.length > 0);
+}
+async function show_file(spec) {
+  return await git_spawn.read(["show", spec]);
+}
+var MERGE_COUNT_ARGUMENTS = [
+  "rev-list",
+  "--count",
+  "--merges",
+  FIRST_PARENT_FLAG
+];
+function merge_count_arguments(range) {
+  return [...MERGE_COUNT_ARGUMENTS, range];
+}
+async function count_merges(range) {
+  const output = await git_spawn.read(merge_count_arguments(range));
+  const parsed = Number(output.trim());
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+var git_command = {
+  GIT_DIRECTORY_ARGUMENTS,
+  branch,
+  status,
+  repository_root,
+  head_commit,
+  git_directories,
+  diff_cached,
+  diff_cached_names,
+  diff_main,
+  change_base,
+  change_base_commit,
+  diff_main_names,
+  diff_main_numstat,
+  untracked_names,
+  get_default_branch,
+  default_branch_reference,
+  fetch_branch,
+  merge_fast_forward,
+  merge_branch,
+  checkout_b,
+  checkout,
+  commit,
+  commit_count_beyond,
+  delete_branch,
+  push: push2,
+  pull_fast_forward,
+  branch_exists,
+  branch_names,
+  branch_names_remote,
+  add_tracked,
+  add_path,
+  log_first_parent,
+  show_file,
+  count_merges,
+  merge_count_arguments,
+  is_upstream_not_set_error
+};
+
+// scripts/run/run-hold.ts
+import { z } from "zod";
+var HOLD_PREFIX = "josh-run-hold-";
+var UNNUMBERED_ISSUE = "new";
+var HOLD_MAX_AGE_HOURS = 8;
+var MILLISECONDS_PER_HOUR = 36e5;
+var HOLD_MAX_AGE_MS = HOLD_MAX_AGE_HOURS * MILLISECONDS_PER_HOUR;
+var RELEASE_COMMAND = "pnpm josh run:release";
+var FORCE_RELEASE_COMMAND = `${RELEASE_COMMAND} --force`;
+var NOT_IDLE = 'that is not "nothing is running here"';
+var FREE_READ = { kind: "free" };
+var UNREADABLE_READ = { kind: "unreadable" };
+function hold_path(git_directory) {
+  return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
+}
+async function worktree_directory() {
+  const directories = await git_command.git_directories();
+  return directories[0];
+}
+async function is_linked_worktree() {
+  const directories = await git_command.git_directories();
+  return directories[0] !== void 0 && directories[0] !== directories[1];
+}
+var run_hold_schema = z.object({
+  issue: z.string(),
+  taken_at: z.string(),
+  pid: z.number()
+});
+function parse_hold(raw) {
+  try {
+    const parsed = run_hold_schema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function is_stale(hold, now) {
+  const taken = Date.parse(hold.taken_at);
+  if (Number.isNaN(taken)) return true;
+  return now.getTime() - taken > HOLD_MAX_AGE_MS;
+}
+function classify(raw, now) {
+  if (raw === void 0) return FREE_READ;
+  const hold = parse_hold(raw);
+  if (hold === void 0) return UNREADABLE_READ;
+  return { kind: is_stale(hold, now) ? "stale" : "held", hold };
+}
+function read_hold(target, now = /* @__PURE__ */ new Date()) {
+  return classify(stamp_file.read_stamp_text(target), now);
+}
+function build_hold(issue, now) {
+  return { issue, taken_at: now.toISOString(), pid: process.pid };
+}
+function write_hold(target, issue, now = /* @__PURE__ */ new Date()) {
+  const hold = build_hold(issue, now);
+  stamp_file.write_stamp(target, hold);
+  return hold;
+}
+function create_hold(target, issue, now = /* @__PURE__ */ new Date()) {
+  return stamp_file.create_stamp(target, build_hold(issue, now));
+}
+async function is_tree_dirty() {
+  try {
+    const status2 = await git_command.status();
+    return status2.trim() !== "";
+  } catch {
+    return true;
+  }
+}
+function release_hold(target) {
+  stamp_file.remove_stamp(target);
+}
+function describe_holder(hold) {
+  const holder = hold.issue === UNNUMBERED_ISSUE ? "an unnumbered run" : `#${hold.issue}`;
+  return `${holder}, recorded ${hold.taken_at} (pid ${String(hold.pid)})`;
+}
+function own_release_command(issue) {
+  return issue === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue}`;
+}
+function is_own_hold(hold, claimant) {
+  return hold.issue === claimant;
+}
+function held_message(hold) {
+  return `This working tree is already held by ${describe_holder(hold)}. One run at a time per working tree: a second run here commits its files onto the other run's branch. If that record is stale, run \`${FORCE_RELEASE_COMMAND}\` in this working tree \u2014 it removes a record this run did not write, so be sure the run that did has ended \u2014 and ask again.`;
+}
+function foreign_release_message(hold) {
+  return `This working tree is held by ${describe_holder(hold)}, and this release did not claim it \u2014 nothing was removed. Release it as that run with \`${own_release_command(hold.issue)}\`, or, once you are sure it has ended, remove the record with \`${FORCE_RELEASE_COMMAND}\`.`;
+}
+function forced_release_message(hold) {
+  return `Forced: removed the run record held by ${describe_holder(hold)}.`;
+}
+function unreadable_message() {
+  return `This working tree's run record could not be read \u2014 ${NOT_IDLE}. Run \`${FORCE_RELEASE_COMMAND}\` in this working tree to clear it, then ask again.`;
+}
+function stale_message(hold) {
+  return `Replaced a stale run record held by ${describe_holder(hold)}: older than ${String(HOLD_MAX_AGE_HOURS)} hours, so the run that wrote it has ended without releasing it.`;
+}
+function uncommitted_message(hold) {
+  return `This working tree still has uncommitted changes, and its run record \u2014 held by ${describe_holder(hold)} \u2014 has expired. That is a run which stopped for a person rather than one that finished, so the tree is not free: commit or stash the work, or run \`${own_release_command(hold.issue)}\` once you are done with it, then ask again.`;
+}
+function race_message(read2, target) {
+  if (read2.kind === "held") return held_message(read2.hold);
+  return `A record already exists at ${target} and this run did not write it \u2014 ${NOT_IDLE}. Either another run claimed the tree at the same moment, or the record belongs to another account. Run \`${FORCE_RELEASE_COMMAND}\`, and remove that file by hand if it is still there.`;
+}
+function unknown_message() {
+  return `Could not read this working tree's git directory \u2014 ${NOT_IDLE}. Run this from inside the checkout the run will edit.`;
+}
+var run_hold = {
+  FORCE_RELEASE_COMMAND,
+  HOLD_MAX_AGE_HOURS,
+  HOLD_MAX_AGE_MS,
+  RELEASE_COMMAND,
+  UNNUMBERED_ISSUE,
+  classify,
+  create_hold,
+  describe_holder,
+  foreign_release_message,
+  forced_release_message,
+  held_message,
+  hold_path,
+  is_linked_worktree,
+  is_own_hold,
+  is_tree_dirty,
+  own_release_command,
+  parse_hold,
+  race_message,
+  read_hold,
+  release_hold,
+  stale_message,
+  uncommitted_message,
+  unknown_message,
+  unreadable_message,
+  worktree_directory,
+  write_hold
+};
+
+// scripts/run/run-cut.ts
+import { execFileSync } from "node:child_process";
+
+// scripts/backlog/backlog-budget.ts
+var MS_PER_MINUTE = 6e4;
+var MINUTES_PER_HOUR = 60;
+var WHOLE_RUN_BUDGET_HOURS = 8;
+var WHOLE_RUN_BUDGET_MINUTES = WHOLE_RUN_BUDGET_HOURS * MINUTES_PER_HOUR;
+var WHOLE_RUN_BUDGET_MS = WHOLE_RUN_BUDGET_MINUTES * MS_PER_MINUTE;
+var DEFAULT_IDLE_MINUTES = 30;
+var DEFAULT_IDLE_MS = DEFAULT_IDLE_MINUTES * MS_PER_MINUTE;
+var IDLE_POLL_MINUTES = 5;
+var RUN_VERDICT = "run";
+var WATCH_VERDICT = "watch";
+var STOP_VERDICT = "stop";
+var ANSWERS = ["blocked", "candidates", "exhausted", "parked", "unreadable"];
+var WHOLE_RUN_REASON = `The whole-run bound of ${String(WHOLE_RUN_BUDGET_HOURS)} hours has passed. An unattended run that has not finished overnight needs a person, not more waiting.`;
+var PARKED_REASON = "Nothing opted in can proceed without a person. Report the parked issues and finish.";
+var UNREADABLE_REASON = "The backlog listing could not be read, so nothing was offered. Report what the command printed and finish \u2014 it is not an empty backlog.";
+var BLOCKED_REASON = "Everything opted in is blocked or already running, so waiting can still change the answer. Poll again at the polling interval.";
+var NO_IDLE_WATCH_REASON = "The backlog is empty and the idle watch was turned off with `--idle 0`, so the run finishes here.";
+function to_minutes(duration_ms) {
+  return String(Math.ceil(duration_ms / MS_PER_MINUTE));
+}
+function max_reached_reason(merged, max_issues) {
+  return `This run's maximum of ${String(max_issues)} is reached, with ${String(merged)} merged. Report what was done, including how many were picked up during an idle watch, and finish.`;
+}
+function draining_reason(running, reason) {
+  return `Start nothing more and poll until the running children merge (running: ${String(running)}). Then report and finish \u2014 ${reason}`;
+}
+function idle_expired_reason(idle_budget_ms) {
+  return `The backlog stayed empty for the whole ${to_minutes(idle_budget_ms)}-minute idle watch. Report what was done, including how many were picked up during the watch, and finish.`;
+}
+function next_ask_minutes(left_ms) {
+  const left_minutes = Number(to_minutes(left_ms));
+  return String(Math.min(IDLE_POLL_MINUTES, left_minutes));
+}
+function idle_watch_reason(left_ms) {
+  return `The backlog is empty and the idle watch has about ${to_minutes(left_ms)} minutes left. Release the working tree, ask again in ${next_ask_minutes(left_ms)} minutes, and restart the watch the moment a candidate appears.`;
+}
+function running_watch_reason(running, left_ms) {
+  return `The backlog is empty and the idle watch has about ${to_minutes(left_ms)} minutes left, with ${String(running)} still running. Keep the working tree until they merge and poll at the polling interval, not the idle poll \u2014 the watch is running down meanwhile.`;
+}
+function watching_reason(input, left_ms) {
+  if (input.running === 0) return idle_watch_reason(left_ms);
+  return running_watch_reason(input.running, left_ms);
+}
+function taken_by(input) {
+  return input.merged + input.running;
+}
+function run_reason(input) {
+  const { max_issues } = input;
+  if (max_issues === void 0) return "No maximum was given, so start every issue offered.";
+  return `Start at most ${String(max_issues - taken_by(input))} more: this run's maximum is ${String(max_issues)}, with ${String(input.merged)} merged and ${String(input.running)} running.`;
+}
+var ANSWER_STOP_REASONS = {
+  parked: PARKED_REASON,
+  unreadable: UNREADABLE_REASON
+};
+function whole_run_reason(input) {
+  if (input.now_ms - input.started_at_ms < WHOLE_RUN_BUDGET_MS) return void 0;
+  return WHOLE_RUN_REASON;
+}
+function stop_reason(input) {
+  return ANSWER_STOP_REASONS[input.answer] ?? whole_run_reason(input);
+}
+function stopping(input, reason) {
+  if (input.running === 0) return { verdict: STOP_VERDICT, reason };
+  return { verdict: WATCH_VERDICT, reason: draining_reason(input.running, reason) };
+}
+function max_decision(input) {
+  const { max_issues } = input;
+  if (max_issues === void 0 || taken_by(input) < max_issues) return void 0;
+  return stopping(input, max_reached_reason(input.merged, max_issues));
+}
+function idle_decision(input) {
+  const { idle_budget_ms } = input;
+  if (idle_budget_ms === void 0) return stopping(input, NO_IDLE_WATCH_REASON);
+  const left_ms = idle_budget_ms - (input.now_ms - input.active_at_ms);
+  if (left_ms <= 0) return stopping(input, idle_expired_reason(idle_budget_ms));
+  return { verdict: WATCH_VERDICT, reason: watching_reason(input, left_ms) };
+}
+function decide(input) {
+  const reason = stop_reason(input);
+  if (reason !== void 0) return stopping(input, reason);
+  const capped = max_decision(input);
+  if (capped !== void 0) return capped;
+  if (input.answer === "candidates") return { verdict: RUN_VERDICT, reason: run_reason(input) };
+  if (input.answer === "blocked") return { verdict: WATCH_VERDICT, reason: BLOCKED_REASON };
+  return idle_decision(input);
+}
+var backlog_budget = {
+  ANSWERS,
+  ANSWER_STOP_REASONS,
+  BLOCKED_REASON,
+  DEFAULT_IDLE_MINUTES,
+  DEFAULT_IDLE_MS,
+  IDLE_POLL_MINUTES,
+  MS_PER_MINUTE,
+  NO_IDLE_WATCH_REASON,
+  PARKED_REASON,
+  RUN_VERDICT,
+  STOP_VERDICT,
+  UNREADABLE_REASON,
+  WATCH_VERDICT,
+  WHOLE_RUN_BUDGET_HOURS,
+  WHOLE_RUN_BUDGET_MINUTES,
+  WHOLE_RUN_BUDGET_MS,
+  WHOLE_RUN_REASON,
+  decide,
+  draining_reason,
+  idle_expired_reason,
+  idle_watch_reason,
+  max_reached_reason,
+  run_reason,
+  running_watch_reason,
+  taken_by
+};
+
+// scripts/cost-runtime/context-cut-threshold.ts
+var CONTEXT_CUT_THRESHOLD = 2e5;
+var RECENT_REQUEST_WINDOW = 10;
+
+// scripts/lane/lane-child-invocation.ts
+var CHILD_INVOCATION = "fullrun";
+var RESUME_GUIDE = ".claude/skills/workflow-commands/pre-gate-cut.md";
+function child_invocation(issue) {
+  run_issue_number.require_issue_number(issue);
+  return `${CHILD_INVOCATION} #${issue}`;
+}
+function resume_invocation(issue) {
+  const preamble = `Resuming the lane child for issue #${issue} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:cut --resume ${issue}\` before anything else and follow the matching verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Only on \`fresh\` proceed as an ordinary`;
+  return `${preamble} ${child_invocation(issue)}`;
+}
+function outage_resume_invocation(issue) {
+  const preamble = `Resuming the lane child for issue #${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)}`;
+}
+var lane_child_invocation = {
+  CHILD_INVOCATION,
+  child_invocation,
+  outage_resume_invocation,
+  resume_invocation
+};
+
+// scripts/run/run-cut.ts
+import { z as z2 } from "zod";
+var CUT_PREFIX = "josh-run-cut-";
+var PRE_GATE_PHASE = "pre-gate";
+var IMPLEMENTATION_PHASE = "implementation";
+var IMPLEMENTATION_CONTEXT_THRESHOLD = CONTEXT_CUT_THRESHOLD;
+var CUT_MAX_AGE_MS = backlog_budget.WHOLE_RUN_BUDGET_MS;
+var CUT_MAX_AGE_HOURS = backlog_budget.WHOLE_RUN_BUDGET_HOURS;
+var GIT_READ_TIMEOUT_MS = 5e3;
+var END_COMMAND = "pnpm josh run:cut --end";
+var READ_COMMAND = "pnpm josh run:cut --json";
+var NONE_READ = { kind: "none" };
+var UNREADABLE_READ2 = { kind: "unreadable" };
+var run_cut_schema = z2.object({
+  invocation: z2.string(),
+  issue: z2.string(),
+  branch: z2.string(),
+  phase: z2.string(),
+  cut_at: z2.string(),
+  is_handed_off: z2.boolean().optional()
+});
+function cut_path(git_directory) {
+  return stamp_file.stamp_path(CUT_PREFIX, git_directory);
+}
+var { worktree_directory: worktree_directory2 } = run_hold;
+function invocation_for(issue) {
+  return lane_child_invocation.child_invocation(issue);
+}
+function parse_cut(raw) {
+  try {
+    const parsed = run_cut_schema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function is_expired(cut, now) {
+  const started = Date.parse(cut.cut_at);
+  if (Number.isNaN(started)) return true;
+  return now.getTime() - started > CUT_MAX_AGE_MS;
+}
+function classify2(raw, now) {
+  if (raw === void 0) return NONE_READ;
+  const cut = parse_cut(raw);
+  if (cut === void 0) return UNREADABLE_READ2;
+  return { kind: is_expired(cut, now) ? "expired" : "carried", cut };
+}
+function read_cut(target, now = /* @__PURE__ */ new Date()) {
+  return classify2(stamp_file.read_stamp_text(target), now);
+}
+function worktree_git_directory_sync() {
+  try {
+    const output = execFileSync(
+      git_utilities.get_git_command_for_spawn(),
+      [...git_command.GIT_DIRECTORY_ARGUMENTS],
+      // git's own diagnostics are discarded: a checkout it cannot describe is already the
+      // `undefined` below, and a hook that let `fatal: not a git repository` through would print it
+      // in front of a tool call that is about to be allowed.
+      // A `PreToolUse` hook holds the tool call while it runs, so the read is bounded rather than
+      // left to whatever git does.
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: GIT_READ_TIMEOUT_MS }
+    );
+    return output.split("\n").find((line) => line !== "");
+  } catch {
+    return void 0;
+  }
+}
+function carried_cut_sync(now = /* @__PURE__ */ new Date(), directory = worktree_git_directory_sync()) {
+  if (directory === void 0) return void 0;
+  const read2 = read_cut(cut_path(directory), now);
+  return read2.kind === "carried" ? read2.cut : void 0;
+}
+function fresh_cut(spec, now) {
+  return {
+    invocation: invocation_for(spec.issue),
+    issue: spec.issue,
+    branch: spec.branch,
+    phase: spec.phase,
+    cut_at: now.toISOString(),
+    is_handed_off: true
+  };
+}
+function begin_cut(target, spec, now = /* @__PURE__ */ new Date()) {
+  const cut = fresh_cut(spec, now);
+  return stamp_file.create_stamp(target, cut) ? cut : void 0;
+}
+function is_declared_cut(cut, issue) {
+  return cut.is_handed_off === true && cut.invocation === invocation_for(issue);
+}
+function matches_state(cut, request) {
+  return cut.branch === request.current_branch && cut.issue === request.issue && request.is_dirty && request.is_held;
+}
+function is_adopted_cut(cut, issue) {
+  return cut.is_handed_off === false && cut.invocation === invocation_for(issue);
+}
+function classify_resume(cut, request) {
+  if (is_adopted_cut(cut, request.issue)) return "handed-off";
+  if (!is_declared_cut(cut, request.issue)) return "stale";
+  return matches_state(cut, request) ? "resume" : "stale";
+}
+function adopt_cut(target, cut) {
+  const next = { ...cut, is_handed_off: false };
+  stamp_file.remove_stamp(target);
+  return stamp_file.create_stamp(target, next) ? next : void 0;
+}
+function end_cut(target) {
+  stamp_file.remove_stamp(target);
+}
+function tree_is_held(directory) {
+  if (directory === void 0) return false;
+  const read2 = run_hold.read_hold(run_hold.hold_path(directory));
+  return read2.kind === "held" || read2.kind === "stale";
+}
+async function current_state() {
+  const branch2 = await git_command.branch();
+  const is_dirty = await run_hold.is_tree_dirty();
+  const directory = await worktree_directory2();
+  return { branch: branch2, is_dirty, is_held: tree_is_held(directory) };
+}
+function describe_cut(cut) {
+  return `${cut.invocation} cut at ${cut.cut_at} on ${cut.branch} (${cut.phase})`;
+}
+function busy_message(cut) {
+  return `Another process already resumed this cut \u2014 ${describe_cut(cut)}. Nothing was resumed here; a double launch was detected.`;
+}
+function handed_off_message(cut) {
+  return `This cut was already handed off to a successor \u2014 ${describe_cut(cut)}. Nothing was resumed here; the run is being carried on by the process that adopted it, so this one has nothing to do.`;
+}
+function stale_message2(cut) {
+  return `This cut does not match the current tree \u2014 ${describe_cut(cut)}. Resume failed; verify the branch and the uncommitted work, then clear it with \`${END_COMMAND}\` if the run is over.`;
+}
+function unreadable_message2() {
+  return `A cut record is here but could not be read; clear it with \`${END_COMMAND}\` once you know no run is using it. Read it with \`${READ_COMMAND}\`.`;
+}
+function unknown_message2() {
+  return "This working tree\u2019s git directory could not be read, so no cut record was acted on.";
+}
+var run_cut = {
+  CUT_MAX_AGE_HOURS,
+  CUT_MAX_AGE_MS,
+  END_COMMAND,
+  IMPLEMENTATION_CONTEXT_THRESHOLD,
+  IMPLEMENTATION_PHASE,
+  PRE_GATE_PHASE,
+  adopt_cut,
+  begin_cut,
+  busy_message,
+  carried_cut_sync,
+  classify: classify2,
+  classify_resume,
+  current_state,
+  cut_path,
+  describe_cut,
+  end_cut,
+  fresh_cut,
+  handed_off_message,
+  invocation_for,
+  is_expired,
+  read_cut,
+  stale_message: stale_message2,
+  unknown_message: unknown_message2,
+  unreadable_message: unreadable_message2,
+  worktree_directory: worktree_directory2,
+  worktree_git_directory_sync
+};
+
+// scripts/git/issue-labels.ts
+var NEEDS_DECISION_LABEL = "needs-decision";
+
+// scripts/rules/shell-segments.ts
+var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
+function segments_of(command) {
+  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
+}
+function is_josh_command(segment, names) {
+  const named = time_shell.josh_command_of(segment);
+  if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
+  return names.has(named.slice(time_shell.JOSH_PREFIX.length));
+}
+var shell_segments = {
+  SEGMENT_SEPARATOR,
+  is_josh_command,
+  segments_of
+};
+
+// scripts/rules/lane-park.ts
+var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
+var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
+function is_confirmation_notify(command) {
+  return shell_segments.segments_of(command).some(
+    (segment) => shell_segments.is_josh_command(segment, NOTIFY_COMMANDS) && CONFIRMATION_TASK_TYPE.test(segment)
+  );
+}
+var NOTIFY_INVOCATION = /josh\s+(?:notify|nf)\b/u;
+function mentions_confirmation_notify(text) {
+  return NOTIFY_INVOCATION.test(text) && CONFIRMATION_TASK_TYPE.test(text);
+}
+function is_unparked_stop(command, is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
+  if (!is_confirmation_notify(command)) return false;
+  return is_lane_child;
+}
+var APPLIES_NEEDS_DECISION = new RegExp(
+  String.raw`(?:labels\[\]=|--add-label[= ]'?)${NEEDS_DECISION_LABEL}\b`,
+  "u"
+);
+function records_the_park(command) {
+  return APPLIES_NEEDS_DECISION.test(command);
+}
+var LANE_PARK_REASON = '\u26D4 lane child park: this session is a dispatched lane child, and a stop that waits on a person must leave the question on the Issue before it sends this Telegram \u2014 otherwise the parent finds an OPEN Issue with `in-progress` and no question, and a person cannot tell what to answer (joshuafolkken/kit#2034 measured this twice in one run). The child is the only process that knows the question, the options and whether it stashed, so it records the park itself rather than leaving the parent to guess from a log. Before you notify and stop: apply `needs-decision` and post a comment carrying the question, the options, and whether work was stashed \u2014 `gh api repos/{owner}/{repo}/issues/<N>/labels -f \'labels[]=needs-decision\'` then `pnpm josh issue:comment <N> --body-file <path>`. If this stop is a `needs-human-review` or `already-done` one, that label is already on the Issue and there is nothing to add. Then reissue this notify \u2014 it fires once per run and cannot repeat on the call in hand. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "A lane child records its park before it stops", and the park itself is `backlogrun-park.md` \u2192 "park and continue".';
+var lane_park = {
+  LANE_PARK_REASON,
+  is_confirmation_notify,
+  is_unparked_stop,
+  mentions_confirmation_notify,
+  records_the_park
+};
+
+export {
+  git_utilities,
+  shell_segments,
+  CONTEXT_CUT_THRESHOLD,
+  RECENT_REQUEST_WINDOW,
+  run_hold,
+  run_cut,
+  lane_park
+};