@joshuafolkken/kit 1.1514.0 → 1.1784.0

package/dist/hooks/chunk-WK6SMBIC.js

@@ -1,3180 +0,0 @@
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  agent_role_profile,
-  agent_session_role
-} from "./chunk-UPUZF3AN.js";
-import {
-  lane_child_marker
-} from "./chunk-LAOV7NLM.js";
-import {
-  ENV_FILE_NAME,
-  GIT_LOCATION_VARIABLES,
-  LANE_SEAT_KEY,
-  PORCELAIN_FLAG,
-  PORT_SEED_KEY,
-  agent_session_environment,
-  changed_paths,
-  file_reader,
-  git_command,
-  git_location_environment,
-  git_spawn,
-  git_utilities,
-  has_timed_out,
-  issue_number_shape,
-  json_value,
-  lane_paths,
-  ports,
-  process_identity,
-  process_owner_schema,
-  rest_comment_schema,
-  run_carry
-} from "./chunk-APUO6U4J.js";
-import {
-  COMMAND_TIMEOUT_MS,
-  INSTALL_TIMEOUT_MS,
-  PLATFORM_TEMP_ROOT,
-  PROBE_TIMEOUT_MS,
-  SUITE_TIMEOUT_MS,
-  stamp_file
-} from "./chunk-DGT54IH5.js";
-
-// scripts/discovery/repo-discovery.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import path from "node:path";
-
-// scripts/discovery/repo-origin.ts
-var GITHUB_HOST = "github.com";
-var SSH_ALIAS_PATTERN = /^github(?:-\w+)*$/u;
-var GIT_SUFFIX = ".git";
-var PATH_SEPARATOR = "/";
-var USER_SEPARATOR = "@";
-var HOST_SEPARATOR = ":";
-var OWNER_INDEX = 0;
-var REPO_INDEX = 1;
-var REPO_PATH_SEGMENTS = 2;
-var NOT_FOUND = -1;
-var SECTION_PREFIX = "[";
-var ORIGIN_SECTION = /^\[remote\s+"origin"\]$/u;
-var REMOTE_SECTION = /^\[remote\s+"[^"]+"\]$/u;
-var URL_KEY = "url";
-function is_github_hostname(host) {
-  return host.toLowerCase() === GITHUB_HOST;
-}
-function is_github_ssh_host(host) {
-  const normalized = host.toLowerCase();
-  return is_github_hostname(normalized) || SSH_ALIAS_PATTERN.test(normalized);
-}
-function strip_git_suffix(name) {
-  return name.endsWith(GIT_SUFFIX) ? name.slice(0, -GIT_SUFFIX.length) : name;
-}
-function to_identity(repository_path) {
-  const segments = repository_path.split(PATH_SEPARATOR).filter((segment) => segment !== "");
-  if (segments.length !== REPO_PATH_SEGMENTS) return void 0;
-  const owner = segments[OWNER_INDEX] ?? "";
-  const repo = strip_git_suffix(segments[REPO_INDEX] ?? "");
-  return repo === "" ? void 0 : { owner, repo };
-}
-function parse_scp_like(url) {
-  const user_end = url.indexOf(USER_SEPARATOR);
-  const authority = user_end === NOT_FOUND ? url : url.slice(user_end + 1);
-  const host_end = authority.indexOf(HOST_SEPARATOR);
-  if (host_end === NOT_FOUND || !is_github_ssh_host(authority.slice(0, host_end))) return void 0;
-  return to_identity(authority.slice(host_end + 1));
-}
-function parse_url_like(url) {
-  try {
-    const parsed = new URL(url);
-    return is_github_hostname(parsed.hostname) ? to_identity(parsed.pathname) : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function parse_origin_url(url) {
-  const trimmed = url.trim();
-  if (trimmed === "") return void 0;
-  return parse_url_like(trimmed) ?? parse_scp_like(trimmed);
-}
-function is_section_header(line) {
-  return line.startsWith(SECTION_PREFIX);
-}
-function origin_section_lines(lines) {
-  const start = lines.findIndex((line) => ORIGIN_SECTION.test(line));
-  if (start === NOT_FOUND) return [];
-  const rest = lines.slice(start + 1);
-  const end = rest.findIndex((line) => is_section_header(line));
-  return end === NOT_FOUND ? rest : rest.slice(0, end);
-}
-function url_value(line) {
-  const separator = line.indexOf("=");
-  if (separator === NOT_FOUND || line.slice(0, separator).trim() !== URL_KEY) return void 0;
-  return line.slice(separator + 1).trim();
-}
-function parse_origin_from_config(content) {
-  const lines = content.split("\n").map((line) => line.trim());
-  return origin_section_lines(lines).map((line) => url_value(line)).find((url) => url !== void 0);
-}
-function section_groups(lines) {
-  const groups = [];
-  for (const line of lines) {
-    if (is_section_header(line)) groups.push([line]);
-    else groups.at(-1)?.push(line);
-  }
-  return groups;
-}
-function parse_remote_urls_from_config(content) {
-  const lines = content.split("\n").map((line) => line.trim());
-  return section_groups(lines).filter((group) => REMOTE_SECTION.test(group[0] ?? "")).flatMap((group) => group.map((line) => url_value(line))).filter((url) => url !== void 0);
-}
-function format_identity(identity) {
-  return `${identity.owner}${PATH_SEPARATOR}${identity.repo}`.toLowerCase();
-}
-var repo_origin = {
-  GITHUB_HOST,
-  is_github_hostname,
-  is_github_ssh_host,
-  parse_origin_from_config,
-  parse_origin_url,
-  parse_remote_urls_from_config,
-  format_identity
-};
-
-// scripts/discovery/repo-map-logic.ts
-var OVERRIDE_ENTRY_SEPARATOR = ",";
-var OVERRIDE_PAIR_SEPARATOR = "=";
-var OVERRIDE_PAIR_PARTS = 2;
-var KEY_INDEX = 0;
-var PATH_INDEX = 1;
-function is_same_owner(identity, current_owner) {
-  return identity.owner.toLowerCase() === current_owner.toLowerCase();
-}
-function add_entry(target, origin_url, repository_path, current_owner) {
-  if (origin_url === void 0) return;
-  const identity = repo_origin.parse_origin_url(origin_url);
-  if (identity === void 0 || !is_same_owner(identity, current_owner)) return;
-  target.set(repo_origin.format_identity(identity), repository_path);
-}
-function parse_override_entry(entry) {
-  const parts = entry.split(OVERRIDE_PAIR_SEPARATOR).map((part) => part.trim());
-  if (parts.length !== OVERRIDE_PAIR_PARTS) return void 0;
-  const key = parts[KEY_INDEX] ?? "";
-  const repository_path = parts[PATH_INDEX] ?? "";
-  if (repository_path === "") return void 0;
-  return { path: repository_path, origin_url: `https://${repo_origin.GITHUB_HOST}/${key}` };
-}
-function parse_overrides(raw) {
-  if (raw === void 0) return [];
-  return raw.split(OVERRIDE_ENTRY_SEPARATOR).map((entry) => parse_override_entry(entry)).filter((entry) => entry !== void 0);
-}
-function build_repository_map(discovered, current_owner, override_value) {
-  const result = /* @__PURE__ */ new Map();
-  for (const entry of discovered) add_entry(result, entry.origin_url, entry.path, current_owner);
-  for (const entry of parse_overrides(override_value)) {
-    add_entry(result, entry.origin_url, entry.path, current_owner);
-  }
-  return result;
-}
-var repo_map_logic = {
-  is_same_owner,
-  build_repository_map
-};
-
-// scripts/discovery/repo-discovery.ts
-var GIT_DIRECTORY = ".git";
-var GIT_CONFIG = "config";
-var GITDIR_PREFIX = "gitdir:";
-var COMMON_DIRECTORY_FILE = "commondir";
-var OVERRIDE_ENV_KEY = "JOSH_REPO_PATHS";
-function resolve_common_directory(git_directory) {
-  const pointer = path.join(git_directory, COMMON_DIRECTORY_FILE);
-  if (!existsSync(pointer)) return git_directory;
-  try {
-    return path.resolve(git_directory, readFileSync(pointer, "utf8").trim());
-  } catch {
-    return git_directory;
-  }
-}
-function follow_git_file(repository_path, git_file) {
-  const pointer = readFileSync(git_file, "utf8").trim();
-  if (!pointer.startsWith(GITDIR_PREFIX)) return void 0;
-  return path.resolve(repository_path, pointer.slice(GITDIR_PREFIX.length).trim());
-}
-function resolve_git_directory(repository_path) {
-  const candidate = path.join(repository_path, GIT_DIRECTORY);
-  if (!existsSync(candidate)) return void 0;
-  try {
-    if (statSync(candidate).isDirectory()) return candidate;
-    const linked = follow_git_file(repository_path, candidate);
-    return linked === void 0 ? void 0 : resolve_common_directory(linked);
-  } catch {
-    return void 0;
-  }
-}
-function read_config(repository_path) {
-  const git_directory = resolve_git_directory(repository_path);
-  if (git_directory === void 0) return void 0;
-  try {
-    return readFileSync(path.join(git_directory, GIT_CONFIG), "utf8");
-  } catch {
-    return void 0;
-  }
-}
-function read_origin_url(repository_path) {
-  const config = read_config(repository_path);
-  return config === void 0 ? void 0 : repo_origin.parse_origin_from_config(config);
-}
-function read_remote_urls(repository_path) {
-  const config = read_config(repository_path);
-  return config === void 0 ? [] : repo_origin.parse_remote_urls_from_config(config);
-}
-function sibling_directories(parent) {
-  try {
-    return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
-  } catch {
-    return [];
-  }
-}
-function scan_siblings(parent) {
-  return sibling_directories(parent).map((repository_path) => ({
-    path: repository_path,
-    origin_url: read_origin_url(repository_path)
-  }));
-}
-function resolve_current_owner(repository_path) {
-  const origin_url = read_origin_url(repository_path);
-  if (origin_url === void 0) return void 0;
-  return repo_origin.parse_origin_url(origin_url)?.owner;
-}
-function main_worktree(repository_path) {
-  const git_directory = resolve_git_directory(repository_path);
-  if (git_directory === void 0 || path.basename(git_directory) !== GIT_DIRECTORY) {
-    return repository_path;
-  }
-  return path.dirname(git_directory);
-}
-function discover_repositories(repository_path, environment3 = process.env) {
-  const main = main_worktree(repository_path);
-  const current_owner = resolve_current_owner(main);
-  if (current_owner === void 0) return /* @__PURE__ */ new Map();
-  return repo_map_logic.build_repository_map(
-    scan_siblings(path.dirname(main)),
-    current_owner,
-    environment3[OVERRIDE_ENV_KEY]
-  );
-}
-var repo_discovery = {
-  OVERRIDE_ENV_KEY,
-  main_worktree,
-  read_origin_url,
-  read_remote_urls,
-  resolve_current_owner,
-  scan_siblings,
-  discover_repositories
-};
-
-// scripts/issue/issue-cite.ts
-var GITHUB_URL_PREFIX = "https://github.com/";
-var ISSUE_PATH = "/issues/";
-var SUMMARY_SEPARATOR = " \u2014 ";
-var REPO_QUALIFIED = /^([^\s/#]+\/[^\s/#]+)#(\d+)$/u;
-var BARE_NUMBER = /^#?(\d+)$/u;
-function plain(number, repo = "") {
-  return `${repo}#${String(number)}`;
-}
-function issue_url(slug, number) {
-  return `${GITHUB_URL_PREFIX}${slug}${ISSUE_PATH}${number}`;
-}
-function citation_line(slug, number, summary) {
-  return `[${plain(number)}](${issue_url(slug, number)})${SUMMARY_SEPARATOR}${summary}`;
-}
-function reference(slug, number, title) {
-  if (slug === void 0) return plain(number);
-  return title === void 0 ? `[${plain(number)}](${issue_url(slug, number)})` : citation_line(slug, number, title);
-}
-function citer(slug, titles) {
-  return function cite(number) {
-    return reference(slug, number, titles.get(number));
-  };
-}
-function qualified_target(token) {
-  const match = REPO_QUALIFIED.exec(token);
-  if (match === null) return void 0;
-  const [, repo = "", number = ""] = match;
-  return { number, repo };
-}
-function bare_target(token, default_repo) {
-  const match = BARE_NUMBER.exec(token);
-  if (match === null) return void 0;
-  const [, number = ""] = match;
-  return { number, repo: default_repo };
-}
-function parse_target(token, default_repo) {
-  return qualified_target(token) ?? bare_target(token, default_repo);
-}
-function label(target) {
-  return plain(target.number, target.repo);
-}
-function missing_line(target) {
-  return `\u2716 ${label(target)}: issue does not resolve \u2014 check the number and the repository`;
-}
-function unreadable_line(target) {
-  return `\u2716 ${label(target)}: could not be read \u2014 a rate limit, expired auth, or a dropped connection`;
-}
-function no_repo_line(target) {
-  return `\u2716 ${label(target)}: could not read this repository \u2014 check gh auth and the origin remote`;
-}
-var issue_cite = {
-  citation_line,
-  citer,
-  issue_url,
-  missing_line,
-  no_repo_line,
-  parse_target,
-  plain,
-  reference,
-  unreadable_line
-};
-
-// scripts/rules/issue-citation.ts
-var ISSUE_NUMBER = /#\d+/gu;
-var REFERENCE_BOUNDARY = /[\s#()[\]<>|]/u;
-var OWNER_REPO = /^[^\s/#]+\/[^\s/#]+$/u;
-var MARKDOWN_LINK = /\[[^[\]]*\]\([^()]*\)/gu;
-var NUMBER_CONTINUATION = /^(?:\w|-[a-z])/iu;
-var CONTINUATION_WIDTH = 2;
-var GLUED_LEAD = /[&./]/u;
-var FENCE_MARKER = /^\s*(?:`{3,}|~{3,})/u;
-var QUOTE_LINE = /^\s*>/u;
-var PR_PREFIX = /\b(?:pr|pull request)\s*$/iu;
-var BACKTICK_PAIR = 2;
-function link_covers(link, index) {
-  const start = link.index ?? 0;
-  return index >= start && index < start + link[0].length;
-}
-function is_linked_at(line, index) {
-  for (const link of line.matchAll(MARKDOWN_LINK)) {
-    if (link_covers(link, index)) return true;
-  }
-  return false;
-}
-function lead_token(message, hash_index) {
-  let start = hash_index;
-  while (start > 0 && !REFERENCE_BOUNDARY.test(message.charAt(start - 1))) start -= 1;
-  return message.slice(start, hash_index);
-}
-function repo_prefix(message, hash_index) {
-  const token = lead_token(message, hash_index);
-  return OWNER_REPO.test(token) ? token : "";
-}
-function is_inline_code_at(line, index) {
-  const backticks = line.slice(0, index).split("`").length - 1;
-  return backticks % BACKTICK_PAIR === 1;
-}
-function is_bare_at(line, index) {
-  if (is_linked_at(line, index) || is_inline_code_at(line, index)) return false;
-  return !PR_PREFIX.test(line.slice(0, index));
-}
-function is_glued(line, reference2) {
-  const end = reference2.index + reference2.text.length;
-  if (NUMBER_CONTINUATION.test(line.slice(end, end + CONTINUATION_WIDTH))) return true;
-  return reference2.prefix === "" && GLUED_LEAD.test(lead_token(line, reference2.index));
-}
-function line_references(line) {
-  const references = [];
-  for (const match of line.matchAll(ISSUE_NUMBER)) {
-    const reference2 = { index: match.index, prefix: repo_prefix(line, match.index), text: match[0] };
-    if (!is_glued(line, reference2) && is_bare_at(line, match.index)) references.push(reference2);
-  }
-  return references;
-}
-function collect_line_references(line, found) {
-  for (const reference2 of line_references(line)) found.push(`${reference2.prefix}${reference2.text}`);
-}
-function lines_outside_fences(message) {
-  const lines = [];
-  let is_in_fence = false;
-  for (const line of message.split("\n")) {
-    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
-    else if (!is_in_fence) lines.push(line);
-  }
-  return lines;
-}
-function prose_lines(message) {
-  return lines_outside_fences(message).filter((line) => !QUOTE_LINE.test(line));
-}
-function bare_references(message) {
-  const found = [];
-  for (const line of prose_lines(message)) collect_line_references(line, found);
-  return [...new Set(found)];
-}
-function prompt_references(prompt) {
-  const found = /* @__PURE__ */ new Set();
-  for (const match of prompt.matchAll(ISSUE_NUMBER)) {
-    found.add(repo_prefix(prompt, match.index) + match[0]);
-  }
-  return found;
-}
-function unquoted_references(message, prompt) {
-  const quoted2 = prompt_references(prompt);
-  return bare_references(message).filter((reference2) => !quoted2.has(reference2));
-}
-function has_bare_reference(message) {
-  return bare_references(message).length > 0;
-}
-function cite_argument(reference2) {
-  return reference2.startsWith("#") ? reference2.slice(1) : reference2;
-}
-function cite_arguments(references) {
-  return references.map((reference2) => cite_argument(reference2));
-}
-function reference_link(reference2, default_slug) {
-  const slug = reference2.prefix === "" ? default_slug : reference2.prefix;
-  const number = reference2.text.slice(1);
-  return `[${reference2.prefix}${reference2.text}](${issue_cite.issue_url(slug, number)})`;
-}
-function linkify_line(line, slug) {
-  let result = "";
-  let cursor = 0;
-  for (const reference2 of line_references(line)) {
-    const start = reference2.index - reference2.prefix.length;
-    result += line.slice(cursor, start) + reference_link(reference2, slug);
-    cursor = reference2.index + reference2.text.length;
-  }
-  return result + line.slice(cursor);
-}
-function rewrite_line(line, slug, is_in_fence) {
-  if (is_in_fence || FENCE_MARKER.test(line) || QUOTE_LINE.test(line)) return line;
-  return linkify_line(line, slug);
-}
-function linkify(message, slug) {
-  const out = [];
-  let is_in_fence = false;
-  for (const line of message.split("\n")) {
-    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
-    out.push(rewrite_line(line, slug, is_in_fence));
-  }
-  return out.join("\n");
-}
-var issue_citation = {
-  bare_references,
-  cite_arguments,
-  has_bare_reference,
-  linkify,
-  prose_lines,
-  unquoted_references
-};
-
-// scripts/issue/session-cite.ts
-function session_repo() {
-  const url = repo_discovery.read_origin_url(process.cwd());
-  const identity = url === void 0 ? void 0 : repo_origin.parse_origin_url(url);
-  return identity === void 0 ? void 0 : `${identity.owner}/${identity.repo}`;
-}
-function issue(number, title, repo = session_repo()) {
-  return issue_cite.reference(repo, String(number), title);
-}
-function text(message) {
-  const repo = session_repo();
-  return repo === void 0 ? message : issue_citation.linkify(message, repo);
-}
-var session_cite = {
-  issue,
-  session_repo,
-  text
-};
-
-// scripts/josh/stamp-record.ts
-var NONE_READ = { kind: "none" };
-var UNREADABLE_READ = { kind: "unreadable" };
-function is_older_than(iso, max_age_ms, now) {
-  const at = Date.parse(iso);
-  if (Number.isNaN(at)) return true;
-  return now.getTime() - at > max_age_ms;
-}
-function classify(raw, spec, now) {
-  if (raw === void 0) return NONE_READ;
-  const record = spec.parse(raw);
-  if (record === void 0) return UNREADABLE_READ;
-  const is_expired2 = is_older_than(spec.timestamp_of(record), spec.max_age_ms, now);
-  return { kind: is_expired2 ? "expired" : "carried", record };
-}
-var stamp_record = { classify, is_older_than };
-
-// scripts/run/hold/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_READ2 = { kind: "unreadable" };
-function hold_path(git_directory) {
-  return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
-}
-async function worktree_directory() {
-  const directories2 = await git_command.git_directories();
-  return directories2[0];
-}
-async function is_linked_worktree() {
-  const directories2 = await git_command.git_directories();
-  return directories2[0] !== void 0 && directories2[0] !== directories2[1];
-}
-var run_hold_schema = z.object({
-  issue: z.string(),
-  taken_at: z.string(),
-  pid: z.number(),
-  is_fullrun: z.boolean().optional(),
-  is_halfrun_stop: z.boolean().optional(),
-  prrun_stop_head: z.string().optional(),
-  owner_pid: z.number().optional(),
-  owner_start: z.string().optional(),
-  notified_at: z.string().optional()
-});
-function parse_hold(raw) {
-  return json_value.parse_with(raw, run_hold_schema);
-}
-function is_expired(hold, now) {
-  return stamp_record.is_older_than(hold.taken_at, HOLD_MAX_AGE_MS, now);
-}
-function is_stop_marked(hold) {
-  return hold.is_halfrun_stop === true || hold.prrun_stop_head !== void 0;
-}
-function is_owner_gone(hold) {
-  if (is_stop_marked(hold) || hold.owner_pid === void 0) return false;
-  return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false;
-}
-function is_stale(hold, now) {
-  return is_expired(hold, now) || is_owner_gone(hold);
-}
-function classify2(raw, now) {
-  if (raw === void 0) return FREE_READ;
-  const hold = parse_hold(raw);
-  if (hold === void 0) return UNREADABLE_READ2;
-  return { kind: is_stale(hold, now) ? "stale" : "held", hold };
-}
-function read_hold(target, now = /* @__PURE__ */ new Date()) {
-  return classify2(stamp_file.read_stamp_text(target), now);
-}
-function session_owner(environment3 = process.env) {
-  const pid = Number(environment3[agent_session_environment.AGENT_PID_KEY]);
-  if (!Number.isSafeInteger(pid) || pid <= 0) return {};
-  return { owner_pid: pid, owner_start: process_identity.read_start(pid) };
-}
-function build_hold(issue2, now, is_fullrun) {
-  return { issue: issue2, taken_at: now.toISOString(), pid: process.pid, is_fullrun, ...session_owner() };
-}
-function write_hold(target, issue2, now = /* @__PURE__ */ new Date()) {
-  const hold = build_hold(issue2, now);
-  stamp_file.write_stamp(target, hold);
-  return hold;
-}
-function create_hold(target, issue2, now = /* @__PURE__ */ new Date(), is_fullrun) {
-  return stamp_file.create_stamp(target, build_hold(issue2, now, is_fullrun));
-}
-var HALFRUN_STOP_FIELDS = { is_halfrun_stop: true };
-function create_stop_hold(target, issue2, mark, now = /* @__PURE__ */ new Date()) {
-  return stamp_file.create_stamp(target, { ...build_hold(issue2, now), ...mark });
-}
-function create_halfrun_stop_hold(target, issue2, now = /* @__PURE__ */ new Date()) {
-  return create_stop_hold(target, issue2, HALFRUN_STOP_FIELDS, now);
-}
-async function is_tree_dirty(directory) {
-  try {
-    const status = await git_command.status(directory);
-    return status.trim() !== "";
-  } catch (error) {
-    error_text.trace_swallowed("run_hold.is_tree_dirty", error);
-    return true;
-  }
-}
-function release_hold(target) {
-  stamp_file.remove_stamp(target);
-}
-function describe_holder(hold) {
-  const holder = hold.issue === UNNUMBERED_ISSUE ? "an unnumbered run" : session_cite.issue(hold.issue);
-  return `${holder}, recorded ${hold.taken_at} (pid ${String(hold.owner_pid ?? hold.pid)})`;
-}
-function own_release_command(issue2) {
-  return issue2 === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue2}`;
-}
-function is_own_hold(hold, claimant) {
-  return hold.issue === claimant;
-}
-function is_reentry(hold, claimant) {
-  return claimant !== UNNUMBERED_ISSUE && is_own_hold(hold, 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) {
-  const why = is_owner_gone(hold) ? "the session that wrote it has ended" : `older than ${String(HOLD_MAX_AGE_HOURS)} hours`;
-  return `Replaced a stale run record held by ${describe_holder(hold)}: ${why}, 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 or outlived its session. 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(read, target) {
-  if (read.kind === "held") return held_message(read.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 = {
-  is_stop_marked,
-  FORCE_RELEASE_COMMAND,
-  HOLD_MAX_AGE_HOURS,
-  HOLD_MAX_AGE_MS,
-  RELEASE_COMMAND,
-  UNNUMBERED_ISSUE,
-  classify: classify2,
-  create_halfrun_stop_hold,
-  create_stop_hold,
-  HALFRUN_STOP_FIELDS,
-  create_hold,
-  foreign_release_message,
-  forced_release_message,
-  held_message,
-  hold_path,
-  is_linked_worktree,
-  is_own_hold,
-  is_reentry,
-  is_tree_dirty,
-  own_release_command,
-  race_message,
-  read_hold,
-  release_hold,
-  session_owner,
-  stale_message,
-  uncommitted_message,
-  unknown_message,
-  unreadable_message,
-  worktree_directory,
-  write_hold
-};
-
-// scripts/agent/agent-headless.ts
-var KEY = "JOSH_AGENT_HEADLESS";
-var VALUE = "1";
-function environment() {
-  return { [KEY]: VALUE };
-}
-function is_headless(source = process.env) {
-  return source[KEY] === VALUE;
-}
-var agent_headless = { KEY, environment, is_headless };
-
-// scripts/josh/session-language.ts
-var ENV_KEY = "JOSH_SESSION_LANG";
-var DEFAULT_SESSION_LANG = "ja";
-function resolve_session_lang() {
-  const value = process.env[ENV_KEY]?.trim();
-  if (value) return { lang: value, is_default: false };
-  return { lang: DEFAULT_SESSION_LANG, is_default: true };
-}
-var session_language = { DEFAULT_SESSION_LANG, ENV_KEY, resolve_session_lang };
-
-// scripts/lane/lane-reap.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-
-// scripts/run/ship/run-ship-stage.ts
-import { z as z2 } from "zod";
-var STAGE = {
-  PREFLIGHT: "preflight",
-  REVIEW: "review",
-  GATE: "gate",
-  SYNC: "sync",
-  COMMIT: "commit",
-  ROUND_TWO: "round-2",
-  FOLLOWUP: "followup",
-  REPORT: "report"
-};
-var PHASE = {
-  START: "start",
-  DONE: "done",
-  FAILED: "failed",
-  SKIPPED: "skipped"
-};
-var RECORD_PREFIX = "josh-ship-stages-";
-var RECORD_SEPARATOR = "-";
-var SKIP_COMMIT_FLAG = "--skip-commit";
-var SKIP_PUSH_FLAG = "--skip-push";
-var WORD_SEPARATOR = " ";
-var STARTED_SEPARATOR = ",";
-var STARTED_INDEX = 3;
-var WORD_COUNT = STARTED_INDEX + 1;
-var record_schema = z2.object({
-  done: z2.array(z2.string()),
-  started: z2.array(z2.string()).default([])
-});
-var EMPTY_RECORD = { done: [], started: [] };
-function record_path(repository2, issue2) {
-  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue2}${RECORD_SEPARATOR}`, repository2);
-}
-function parse_record(raw) {
-  return json_value.parse_with(raw, record_schema) ?? EMPTY_RECORD;
-}
-function read_record(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  return raw === void 0 ? EMPTY_RECORD : parse_record(raw);
-}
-function read_done(target) {
-  return new Set(read_record(target).done);
-}
-function mark_done(target, stage) {
-  const record = read_record(target);
-  stamp_file.replace_stamp(target, { ...record, done: [.../* @__PURE__ */ new Set([...record.done, stage])] });
-}
-function read_started(target) {
-  return read_record(target).started;
-}
-function mark_started(target, stage) {
-  const record = read_record(target);
-  stamp_file.replace_stamp(target, { ...record, started: [.../* @__PURE__ */ new Set([...record.started, stage])] });
-}
-function end_attempt(target) {
-  stamp_file.replace_stamp(target, { ...read_record(target), started: [] });
-}
-function clear(target) {
-  stamp_file.remove_stamp(target);
-}
-function is_shipped(state) {
-  return state.is_committed && state.is_pushed;
-}
-var DONE_BY = {
-  // The preflight asks what the commit stage would refuse on, so a commit is
-  // its output as it is the gate's; a resumed commit stage still asks `git -y`'s own preflight.
-  [STAGE.PREFLIGHT]: (_done, state) => state.is_merged || state.is_committed,
-  // The `--review` round precedes the commit, so a commit is its output as it
-  // is the gate's. A record alone is not honored: before a commit the tree may have been edited since
-  // the recorded round, and only a commit pins the tree that round read.
-  [STAGE.REVIEW]: (_done, state) => state.is_merged || state.is_committed,
-  [STAGE.GATE]: (_done, state) => state.is_merged || state.is_committed,
-  // The merge of the default branch before the commit: once committed, a
-  // conflicting pull request is the followup's to merge again.
-  [STAGE.SYNC]: (_done, state) => state.is_merged || state.is_committed,
-  [STAGE.COMMIT]: (done, state) => state.is_merged || done.has(STAGE.COMMIT) && is_shipped(state),
-  // The round-2 pass reads the pushed fix delta, so its record is honored only
-  // while that push still stands — new work pushed on top reruns it.
-  [STAGE.ROUND_TWO]: (done, state) => state.is_merged || done.has(STAGE.ROUND_TWO) && is_shipped(state),
-  // A recorded followup still needs the shipped state: a record left by a merged ship whose report
-  // failed must not pass over the followup of new, not-yet-pushed work on the same issue.
-  [STAGE.FOLLOWUP]: (done, state) => state.is_merged || done.has(STAGE.FOLLOWUP) && is_shipped(state),
-  [STAGE.REPORT]: (done) => done.has(STAGE.REPORT)
-};
-function is_done(stage, done, state, has_body = false) {
-  if (has_body && stage === STAGE.COMMIT && !state.is_merged) return false;
-  return DONE_BY[stage](done, state);
-}
-function commit_flags(state) {
-  if (!state.is_committed) return [];
-  return state.is_pushed ? [SKIP_COMMIT_FLAG, SKIP_PUSH_FLAG] : [SKIP_COMMIT_FLAG];
-}
-function event_text(issue2, stage, phase, started = []) {
-  const words = [issue_cite.plain(issue2), stage, phase];
-  const listed = [...new Set(started)].join(STARTED_SEPARATOR);
-  const full = started.length > 0 ? [...words, listed] : words;
-  return full.join(WORD_SEPARATOR);
-}
-function started_of(text2) {
-  return text2.split(WORD_SEPARATOR, WORD_COUNT)[STARTED_INDEX]?.split(STARTED_SEPARATOR);
-}
-var CONFLICT = "conflict";
-function stop_reason(stage, conflicts = []) {
-  return conflicts.length > 0 ? CONFLICT : stage;
-}
-var run_ship_stage = {
-  CONFLICT,
-  PHASE,
-  STAGE,
-  clear,
-  commit_flags,
-  end_attempt,
-  event_text,
-  is_done,
-  mark_done,
-  mark_started,
-  read_done,
-  read_started,
-  record_path,
-  started_of,
-  stop_reason
-};
-
-// scripts/run/ship/run-ship-next.ts
-var { STAGE: STAGE2 } = run_ship_stage;
-var COMMAND = {
-  LOG: "pnpm josh ship --log",
-  DETACH: "pnpm josh ship --detach",
-  DETACH_REVIEW: "pnpm josh ship --detach --review"
-};
-var ESCAPED_QUOTE = String.raw`'\''`;
-var BARE_WORD = /^[\w%+,./:=@-]+$/u;
-function quoted(title) {
-  return `'${title.split("'").join(ESCAPED_QUOTE)}'`;
-}
-function shell_word(token) {
-  return BARE_WORD.test(token) ? token : quoted(token);
-}
-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
-  };
-}
-function ship_command(command, resume) {
-  const words = [...resume.flags, resume.title].map((token) => shell_word(token));
-  return [command, ...words].join(" ");
-}
-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 ? COMMAND.DETACH_REVIEW : COMMAND.DETACH;
-  return `leave the fix uncommitted and run \`${ship_command(command, resume)}\`.`;
-}
-var AFTER_FIX = {
-  [STAGE2.PREFLIGHT]: detach_as_started,
-  [STAGE2.REVIEW]: detach_as_started,
-  [STAGE2.GATE]: detach_as_started,
-  [STAGE2.SYNC]: detach_as_started,
-  [STAGE2.COMMIT]: detach_as_started,
-  [STAGE2.ROUND_TWO]: detach_again,
-  [STAGE2.FOLLOWUP]: detach_again,
-  [STAGE2.REPORT]: detach_again
-};
-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(issue2, stage, is_excerpted) {
-  if (is_excerpted) return `Fix the ${stage} failure shown in the output below`;
-  return `Read the stopped report with \`${COMMAND.LOG} ${issue2}\`, fix the ${stage} failure`;
-}
-function next_step(issue2, stage, resume, is_excerpted = false) {
-  const conflicts = resume.conflicts ?? [];
-  if (conflicts.length > 0) return `${conflict_step(conflicts)} ${AFTER_FIX[stage](resume)}`;
-  return `${fix_step(issue2, stage, is_excerpted)}, then ${AFTER_FIX[stage](resume)}`;
-}
-var run_ship_next = { COMMAND, next_step, quoted, resume_of };
-
-// scripts/run/ship/run-ship-stop-context.ts
-import { stripVTControlCharacters } from "node:util";
-import { z as z6 } from "zod";
-
-// scripts/git/git-ls-remote.ts
-var LS_REMOTE_COMMAND = "ls-remote";
-var HEADS_FLAG = "--heads";
-var ORIGIN_REMOTE = "origin";
-var HEADS_REF_PREFIX = "refs/heads/";
-function ls_remote_branch_arguments(branch_name) {
-  return [LS_REMOTE_COMMAND, HEADS_FLAG, ORIGIN_REMOTE, `${HEADS_REF_PREFIX}${branch_name}`];
-}
-
-// scripts/git/repository-lock.ts
-import { randomUUID } from "node:crypto";
-import { linkSync, renameSync, rmSync } from "node:fs";
-import { setTimeout as sleep } from "node:timers/promises";
-
-// scripts/git/git-common-directory.ts
-import { execFileSync } from "node:child_process";
-var OWN_GIT_DIRECTORY = 0;
-var COMMON_GIT_DIRECTORY = 1;
-var PROBE_TIMEOUT_MS2 = 5e3;
-var answers = /* @__PURE__ */ new Map();
-function probe_environment(cwd) {
-  if (cwd === void 0) return process.env;
-  return { ...process.env, ...git_location_environment.location_free_environment() };
-}
-function cache_key(cwd) {
-  if (cwd !== void 0) return `explicit\0${cwd}`;
-  const locations = GIT_LOCATION_VARIABLES.map((name) => process.env[name] ?? "");
-  return ["inherited", process.cwd(), ...locations].join("\0");
-}
-function read_directories(cwd) {
-  try {
-    const output = execFileSync(
-      git_utilities.get_git_command_for_spawn(),
-      [...git_command.GIT_DIRECTORY_ARGUMENTS],
-      {
-        cwd,
-        env: probe_environment(cwd),
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: PROBE_TIMEOUT_MS2
-      }
-    );
-    return output.split("\n").filter((line) => line !== "");
-  } catch {
-    return [];
-  }
-}
-function directories(cwd) {
-  const key = cache_key(cwd);
-  const known = answers.get(key);
-  if (known !== void 0) return known;
-  const read = read_directories(cwd);
-  if (read.length > 0) answers.set(key, read);
-  return read;
-}
-function own(cwd) {
-  return directories(cwd)[OWN_GIT_DIRECTORY];
-}
-function repository(cwd) {
-  return directories(cwd)[COMMON_GIT_DIRECTORY];
-}
-function select_linked(found) {
-  const own_directory = found[OWN_GIT_DIRECTORY];
-  const common = found[COMMON_GIT_DIRECTORY];
-  return own_directory === void 0 || common === void 0 || own_directory === common ? void 0 : common;
-}
-function resolve(cwd) {
-  return select_linked(directories(cwd));
-}
-var git_common_directory = { directories, own, repository, resolve, select_linked };
-
-// scripts/git/repository-lock.ts
-var POLL_INTERVAL_MS = 200;
-var SYNC_POLL_INTERVAL_MS = 10;
-var SLEEP_CELL = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
-function lock_path(prefix, cwd) {
-  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd ?? process.cwd());
-}
-function parse_owner(raw) {
-  if (raw === void 0) return void 0;
-  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
-  return parsed.success ? parsed.data : void 0;
-}
-function read_owner(target) {
-  return parse_owner(stamp_file.read_stamp_text(target));
-}
-function is_owner_gone2(owner) {
-  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
-}
-function restore(aside, target) {
-  try {
-    linkSync(aside, target);
-  } catch {
-  }
-}
-function stale_record(target, is_gone2) {
-  const raw = stamp_file.read_stamp_text(target);
-  const owner = parse_owner(raw);
-  return owner !== void 0 && is_gone2(owner) ? raw : void 0;
-}
-function move_aside(target) {
-  const aside = `${target}.${String(process.pid)}.${randomUUID()}`;
-  try {
-    renameSync(target, aside);
-    return aside;
-  } catch {
-    return void 0;
-  }
-}
-function clear_stale(target, is_gone2 = is_owner_gone2) {
-  const raw = stale_record(target, is_gone2);
-  if (raw === void 0) return;
-  const aside = move_aside(target);
-  if (aside === void 0) return;
-  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target);
-  rmSync(aside, { force: true });
-}
-function claim(target) {
-  clear_stale(target);
-  return stamp_file.create_stamp(target, process_identity.own_fields());
-}
-function release(target) {
-  const owner = read_owner(target);
-  if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
-    stamp_file.remove_stamp(target);
-  }
-}
-async function acquire(target, max_wait_ms) {
-  const deadline = Date.now() + max_wait_ms;
-  while (!claim(target)) {
-    if (Date.now() >= deadline) return false;
-    await sleep(POLL_INTERVAL_MS);
-  }
-  return true;
-}
-function sleep_sync(ms) {
-  Atomics.wait(SLEEP_CELL, 0, 0, ms);
-}
-function acquire_sync(target, max_wait_ms) {
-  const deadline = Date.now() + max_wait_ms;
-  while (!claim(target)) {
-    if (Date.now() >= deadline) return false;
-    sleep_sync(SYNC_POLL_INTERVAL_MS);
-  }
-  return true;
-}
-async function with_lock(work, target, max_wait_ms) {
-  if (!await acquire(target, max_wait_ms)) return void 0;
-  try {
-    return await work();
-  } finally {
-    release(target);
-  }
-}
-function with_lock_sync(work, target, max_wait_ms) {
-  if (!acquire_sync(target, max_wait_ms)) return void 0;
-  try {
-    return work();
-  } finally {
-    release(target);
-  }
-}
-var repository_lock = { clear_stale, lock_path, with_lock, with_lock_sync };
-
-// scripts/git/git-worktree.ts
-var WORKTREE = "worktree";
-var WORKTREE_LOCK_PREFIX = "josh-worktree-lock-";
-var WORKTREE_LOCK_MAX_WAIT_MS = 12e4;
-async function locked(arguments_, timeout_ms) {
-  const target = repository_lock.lock_path(WORKTREE_LOCK_PREFIX);
-  const output = await repository_lock.with_lock(
-    async () => await git_spawn.read(arguments_, timeout_ms),
-    target,
-    WORKTREE_LOCK_MAX_WAIT_MS
-  );
-  if (output === void 0) {
-    throw new Error(
-      `git ${arguments_.join(" ")}: timed out waiting for the work-tree lock ${target}`
-    );
-  }
-  return output;
-}
-async function worktree_list() {
-  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
-}
-async function worktree_add(directory, branch_name, start_point) {
-  const flags = start_point === void 0 ? ["add"] : ["add", "--no-track", "-b", branch_name];
-  return await locked([WORKTREE, ...flags, directory, start_point ?? branch_name], SUITE_TIMEOUT_MS);
-}
-async function worktree_add_detached(directory, commit) {
-  return await locked([WORKTREE, "add", "--detach", directory, commit], SUITE_TIMEOUT_MS);
-}
-async function worktree_remove(directory) {
-  return await locked([WORKTREE, "remove", "--force", directory], INSTALL_TIMEOUT_MS);
-}
-async function worktree_prune() {
-  return await locked([WORKTREE, "prune"]);
-}
-async function ls_remote_branch(branch_name) {
-  return await git_spawn.read_remote(ls_remote_branch_arguments(branch_name));
-}
-async function branch_delete(branch_name) {
-  return await git_spawn.read(["branch", "-D", branch_name]);
-}
-var git_worktree = {
-  branch_delete,
-  ls_remote_branch,
-  worktree_add,
-  worktree_add_detached,
-  worktree_list,
-  worktree_prune,
-  worktree_remove
-};
-
-// scripts/gh/git-gh-api-path.ts
-var FULL_PAGE_QUERY = "?per_page=100";
-function repo_api_path(repo = "{owner}/{repo}") {
-  return `repos/${repo}`;
-}
-function issues_api_path(repo) {
-  return `${repo_api_path(repo)}/issues`;
-}
-function issue_api_path(issue_number, repo) {
-  return `${issues_api_path(repo)}/${issue_number}`;
-}
-function blocked_by_api_path(issue_number, repo) {
-  return `${issue_api_path(issue_number, repo)}/dependencies/blocked_by`;
-}
-function issue_comments_api_path(issue_number, repo) {
-  return `${issue_api_path(issue_number, repo)}/comments`;
-}
-function pulls_api_path(repo) {
-  return `${repo_api_path(repo)}/pulls`;
-}
-function pull_api_path(pr_number, repo) {
-  return `${pulls_api_path(repo)}/${pr_number}`;
-}
-function pull_merge_api_path(pr_number, repo) {
-  return `${pull_api_path(pr_number, repo)}/merge`;
-}
-function pull_comments_api_path(pr_number, repo) {
-  return `${pull_api_path(pr_number, repo)}/comments`;
-}
-function pull_reviews_api_path(pr_number, repo) {
-  return `${pull_api_path(pr_number, repo)}/reviews`;
-}
-function commit_api_path(commit_sha, repo) {
-  return `${repo_api_path(repo)}/commits/${commit_sha}`;
-}
-function commit_check_runs_api_path(commit_sha, repo) {
-  return `${commit_api_path(commit_sha, repo)}/check-runs`;
-}
-function commit_status_api_path(commit_sha, repo) {
-  return `${commit_api_path(commit_sha, repo)}/status`;
-}
-function tag_reference_api_path(tag, repo) {
-  return `${repo_api_path(repo)}/git/ref/tags/${tag}`;
-}
-function release_by_tag_api_path(tag, repo) {
-  return `${repo_api_path(repo)}/releases/tags/${tag}`;
-}
-var git_gh_api_path = {
-  FULL_PAGE_QUERY,
-  repo_api_path,
-  tag_ref_api_path: tag_reference_api_path,
-  release_by_tag_api_path,
-  issues_api_path,
-  issue_api_path,
-  blocked_by_api_path,
-  issue_comments_api_path,
-  pulls_api_path,
-  pull_api_path,
-  pull_merge_api_path,
-  pull_comments_api_path,
-  pull_reviews_api_path,
-  commit_api_path,
-  commit_check_runs_api_path,
-  commit_status_api_path
-};
-
-// scripts/gh/git-gh-exec.ts
-import { execa as execa2, execaSync } from "execa";
-
-// scripts/gh/git-gh-check.ts
-import { execa } from "execa";
-var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
-var gh_check = {};
-async function run_gh_check() {
-  try {
-    await execa("gh", ["--version"], { timeout: COMMAND_TIMEOUT_MS });
-  } catch {
-    delete gh_check.promise;
-    throw new Error(GH_NOT_INSTALLED_MSG);
-  }
-}
-async function check_gh_installed() {
-  gh_check.promise ??= run_gh_check();
-  await gh_check.promise;
-}
-
-// scripts/git/parse-json-array.ts
-function parse_json_loose(raw_json) {
-  return json_value.parse_or_undefined(raw_json);
-}
-function parse_json_array_or_undefined(raw_json, element_schema) {
-  const value = parse_json_loose(raw_json);
-  if (!Array.isArray(value)) return void 0;
-  return element_schema.array().parse(value);
-}
-function read_json_listing(raw_json, element_schema) {
-  try {
-    const rows = parse_json_array_or_undefined(raw_json, element_schema);
-    return rows === void 0 ? { kind: "unreadable" } : { kind: "read", rows };
-  } catch {
-    return { kind: "unexpected_shape" };
-  }
-}
-function parse_json_object_or_undefined(raw_json, schema) {
-  const value = parse_json_loose(raw_json);
-  if (value === void 0) return void 0;
-  return schema.parse(value);
-}
-var parse_json = {
-  parse_json_object_or_undefined
-};
-
-// scripts/gh/git-gh-failure.ts
-import { z as z3 } from "zod";
-var error_document_schema = z3.object({ status: z3.union([z3.string(), z3.number()]).optional() }).catch({});
-var GH_FAILURE_FIELD = "gh_failure";
-function has_gh_failure(error) {
-  return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
-}
-function parse_response_status(stdout) {
-  const document = parse_json.parse_json_object_or_undefined(stdout, error_document_schema);
-  if (document?.status === void 0) return void 0;
-  const status = Number(document.status);
-  return Number.isSafeInteger(status) ? status : void 0;
-}
-function classify_stdout(stdout) {
-  return { status: parse_response_status(stdout) };
-}
-function attach(error, failure) {
-  Object.defineProperty(error, GH_FAILURE_FIELD, {
-    value: failure,
-    enumerable: false,
-    configurable: true
-  });
-  return error;
-}
-function failure_of(error) {
-  return has_gh_failure(error) ? error.gh_failure : void 0;
-}
-var gh_failure = { attach, classify_stdout, failure_of, parse_response_status };
-
-// scripts/gh/git-gh-exec.ts
-var BODY_FROM_STDIN = "-";
-var GH_REQUEST_TIMEOUT_MS = 6e4;
-function to_timeout_option(timeout_ms) {
-  return { timeout: timeout_ms ?? GH_REQUEST_TIMEOUT_MS };
-}
-function direct_environment() {
-  const removed = agent_session_environment.removed_proxy_environment();
-  return Object.keys(removed).length > 0 ? { env: removed } : {};
-}
-function to_spawn_options(timeout_ms, cwd) {
-  return {
-    ...to_timeout_option(timeout_ms),
-    ...direct_environment(),
-    ...cwd !== void 0 && { cwd }
-  };
-}
-var GH_REQUEST_TIMEOUT_MESSAGE = "gh request timed out";
-function has_stderr_field(error) {
-  return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
-}
-function has_stdout_field(error) {
-  return error instanceof Error && "stdout" in error && typeof error.stdout === "string";
-}
-function to_timeout_prefix(error) {
-  return has_timed_out(error) ? `${GH_REQUEST_TIMEOUT_MESSAGE}: ` : "";
-}
-function to_gh_error(error) {
-  const stderr = has_stderr_field(error) ? error.stderr.trim() : "";
-  const stdout = has_stdout_field(error) ? error.stdout.trim() : "";
-  const summary = stderr.length > 0 ? stderr : error_text.message_of(error);
-  const detail = stdout.length > 0 ? `${summary}
-${stdout}` : summary;
-  return gh_failure.attach(
-    new Error(`${to_timeout_prefix(error)}${detail}`, { cause: error }),
-    gh_failure.classify_stdout(stdout)
-  );
-}
-async function exec_gh_command(arguments_, timeout_ms, cwd) {
-  await check_gh_installed();
-  const options = to_spawn_options(timeout_ms, cwd);
-  try {
-    const { stdout } = await execa2("gh", arguments_, options);
-    return stdout.trimEnd();
-  } catch (error) {
-    throw to_gh_error(error);
-  }
-}
-async function exec_gh_command_with_stdin(input) {
-  await check_gh_installed();
-  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms, input.cwd) };
-  try {
-    const { stdout } = await execa2("gh", input.args, options);
-    return stdout.trimEnd();
-  } catch (error) {
-    throw to_gh_error(error);
-  }
-}
-var STATUS_LINE_PATTERN = /^HTTP\/[\d.]+ (?<status>\d{3})\b/u;
-function parse_status_line(output) {
-  const { status } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
-  return status === void 0 ? void 0 : Number(status);
-}
-function status_of_failure(error) {
-  return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
-}
-async function exec_gh_api_status(path6, timeout_ms) {
-  const options = to_spawn_options(timeout_ms);
-  try {
-    await check_gh_installed();
-    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path6], options);
-    return parse_status_line(stdout);
-  } catch (error) {
-    return status_of_failure(error);
-  }
-}
-function exec_gh_api_status_sync(path6, timeout_ms) {
-  const options = to_spawn_options(timeout_ms);
-  try {
-    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path6], options);
-    return parse_status_line(stdout);
-  } catch (error) {
-    return status_of_failure(error);
-  }
-}
-var METHOD_FLAG = "--method";
-var INPUT_FLAG = "--input";
-var PAGINATE_FLAG = "--paginate";
-var SLURP_FLAG = "--slurp";
-var JQ_FLAG = "--jq";
-function optional_flag(flag, value) {
-  return value === void 0 ? [] : [flag, value];
-}
-function to_gh_api_args(request) {
-  const body_args = request.body === void 0 ? [] : [INPUT_FLAG, BODY_FROM_STDIN];
-  const paginate_args = request.should_paginate === true ? [PAGINATE_FLAG] : [];
-  const slurp_args = request.should_slurp === true ? [SLURP_FLAG] : [];
-  return [
-    "api",
-    request.path,
-    ...optional_flag(METHOD_FLAG, request.method),
-    ...body_args,
-    ...paginate_args,
-    ...slurp_args,
-    ...optional_flag(JQ_FLAG, request.jq_filter)
-  ];
-}
-async function exec_gh_api(request) {
-  const args = to_gh_api_args(request);
-  if (request.body === void 0) {
-    return await exec_gh_command(args, request.timeout_ms, request.cwd);
-  }
-  return await exec_gh_command_with_stdin({
-    args,
-    stdin_body: request.body,
-    timeout_ms: request.timeout_ms,
-    cwd: request.cwd
-  });
-}
-function exec_gh_api_sync(request) {
-  const body_option = request.body === void 0 ? {} : { input: request.body };
-  const options = { ...body_option, ...to_spawn_options(request.timeout_ms, request.cwd) };
-  try {
-    const { stdout } = execaSync("gh", to_gh_api_args(request), options);
-    return stdout.trimEnd();
-  } catch (error) {
-    throw to_gh_error(error);
-  }
-}
-function read_gh_api_sync(request) {
-  try {
-    return exec_gh_api_sync(request);
-  } catch {
-    return void 0;
-  }
-}
-var git_gh_exec = {
-  direct_environment,
-  exec_gh_command,
-  exec_gh_command_with_stdin,
-  exec_gh_api,
-  exec_gh_api_sync,
-  read_gh_api_sync,
-  exec_gh_api_status,
-  exec_gh_api_status_sync,
-  parse_status_line
-};
-
-// scripts/gh/git-gh-helpers.ts
-function parse_pr_state_string(result) {
-  const trimmed = result.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function is_pr_already_exists_message(error_message) {
-  return error_message.toLowerCase().includes("already exists");
-}
-function get_error_message_with_stderr(error) {
-  if (!(error instanceof Error)) return String(error);
-  if (has_stderr_field(error) && error.stderr.length > 0) return `${error.message}
-${error.stderr}`;
-  return error.message;
-}
-function handle_pr_create_error(error) {
-  const error_message = get_error_message_with_stderr(error);
-  if (is_pr_already_exists_message(error_message)) {
-    throw new Error("PR_ALREADY_EXISTS");
-  }
-  throw error;
-}
-var git_gh_helpers = {
-  parse_pr_state_string,
-  get_error_message_with_stderr,
-  handle_pr_create_error
-};
-
-// scripts/gh/git-gh-pr-rest.ts
-import { z as z4 } from "zod";
-
-// scripts/gh/git-gh-rest-state.ts
-var MERGED_STATE = "MERGED";
-function to_gh_state(state) {
-  return state?.toUpperCase();
-}
-
-// scripts/gh/git-gh-pr-rest.ts
-var rest_repo_schema = z4.looseObject({ full_name: z4.string().optional() }).nullish();
-var rest_pull_side_schema = z4.looseObject({ repo: rest_repo_schema });
-var rest_pull_schema = z4.looseObject({
-  number: z4.number(),
-  html_url: z4.string().optional(),
-  body: z4.string().nullish(),
-  state: z4.string().optional(),
-  merged: z4.boolean().nullish(),
-  merged_at: z4.string().nullish(),
-  mergeable: z4.boolean().nullish(),
-  mergeable_state: z4.string().optional(),
-  // `sha` is the head commit, which is what both halves of the merge-gate rollup are keyed by —
-  // REST hangs the check runs and the status contexts off the commit rather than off the pull
-  // request.
-  head: z4.looseObject({ ref: z4.string().optional(), sha: z4.string().optional(), repo: rest_repo_schema }).nullish(),
-  base: rest_pull_side_schema.nullish(),
-  // `node_id` is what the GraphQL auto-merge mutation addresses a pull request by, and `auto_merge`
-  // is `null` until auto-merge is enabled — both read by `git-gh-pr-auto-merge.ts`.
-  node_id: z4.string().optional(),
-  auto_merge: z4.looseObject({}).nullish()
-});
-var NOT_A_PULL_MESSAGE = "gh api answered something other than a pull request object";
-var NOT_A_PULL_LISTING_MESSAGE = "gh api answered something other than a pull request listing";
-var NOT_A_COMMENT_LISTING_MESSAGE = "gh api answered something other than a comment listing";
-var OPEN_STATE = "open";
-var EMPTY_BODY = "";
-function parse_rest_pull(rest_json) {
-  const parsed = parse_json_object_or_undefined(rest_json, rest_pull_schema);
-  if (parsed === void 0) throw new Error(NOT_A_PULL_MESSAGE);
-  return parsed;
-}
-function parse_rest_pulls(rest_json) {
-  const parsed = parse_json_array_or_undefined(rest_json, rest_pull_schema);
-  if (parsed === void 0) throw new Error(NOT_A_PULL_LISTING_MESSAGE);
-  return parsed;
-}
-function select_pull(pulls) {
-  return pulls.find((pull) => pull.state === OPEN_STATE) ?? pulls[0];
-}
-function is_merged(pull) {
-  return pull.merged === true || typeof pull.merged_at === "string";
-}
-function to_pr_state(pull) {
-  return is_merged(pull) ? MERGED_STATE : to_gh_state(pull.state);
-}
-function to_repo_name(side) {
-  return side?.repo?.full_name;
-}
-function is_same_repository_head(pull) {
-  const head_repo = to_repo_name(pull.head);
-  return head_repo !== void 0 && head_repo === to_repo_name(pull.base);
-}
-function to_pr_info(pull) {
-  return {
-    mergeable: pull.mergeable,
-    mergeStateStatus: to_gh_state(pull.mergeable_state),
-    state: to_pr_state(pull)
-  };
-}
-function to_pr_comments(rest_json) {
-  const parsed = parse_json_array_or_undefined(rest_json, rest_comment_schema);
-  if (parsed === void 0) throw new Error(NOT_A_COMMENT_LISTING_MESSAGE);
-  return parsed.map((comment) => ({
-    body: comment.body ?? EMPTY_BODY,
-    url: comment.html_url,
-    author: { login: comment.user?.login }
-  }));
-}
-var git_gh_pr_rest = {
-  parse_rest_pull,
-  parse_rest_pulls,
-  select_pull,
-  is_same_repository_head,
-  is_merged,
-  to_pr_state,
-  to_pr_info,
-  to_pr_comments
-};
-
-// scripts/gh/git-gh-pr-read.ts
-var pr_number_by_branch = /* @__PURE__ */ new Map();
-var LOOKUP_QUERY = "state=all&sort=created&direction=desc&per_page=100";
-var COMMENTS_QUERY = FULL_PAGE_QUERY;
-var OWNER_PLACEHOLDER = "{owner}";
-var NO_PULL_REQUEST_MESSAGE = "gh api found no pull request for branch";
-var UNREADABLE_PULL_REQUEST_MESSAGE = "gh api could not read the pull requests for branch";
-function lookup_path(branch_name) {
-  const head = `${OWNER_PLACEHOLDER}:${encodeURIComponent(branch_name)}`;
-  return `${git_gh_api_path.pulls_api_path()}?head=${head}&${LOOKUP_QUERY}`;
-}
-async function fetch_pr_number(branch_name) {
-  const json = await git_gh_exec.exec_gh_api({ path: lookup_path(branch_name) });
-  return git_gh_pr_rest.select_pull(git_gh_pr_rest.parse_rest_pulls(json))?.number;
-}
-var pending_pr_number_by_branch = /* @__PURE__ */ new Map();
-var pull_by_number = /* @__PURE__ */ new Map();
-async function fetch_pr_number_read(branch_name) {
-  try {
-    const pr_number = await fetch_pr_number(branch_name);
-    if (pr_number === void 0) return { kind: "missing" };
-    pr_number_by_branch.set(branch_name, pr_number);
-    return { kind: "read", pr_number };
-  } catch (error) {
-    return { kind: "unreadable", cause: error };
-  }
-}
-async function start_pr_number_read(branch_name) {
-  const pending = pending_pr_number_by_branch.get(branch_name);
-  if (pending !== void 0) return await pending;
-  const lookup = fetch_pr_number_read(branch_name);
-  pending_pr_number_by_branch.set(branch_name, lookup);
-  try {
-    return await lookup;
-  } finally {
-    pending_pr_number_by_branch.delete(branch_name);
-  }
-}
-function forget_pr_numbers() {
-  pr_number_by_branch.clear();
-  pending_pr_number_by_branch.clear();
-  pull_by_number.clear();
-}
-async function read_pr_number(branch_name) {
-  const cached = pr_number_by_branch.get(branch_name);
-  if (cached !== void 0) return { kind: "read", pr_number: cached };
-  return await start_pr_number_read(branch_name);
-}
-async function resolve_pr_number(branch_name) {
-  const read = await read_pr_number(branch_name);
-  return read.kind === "read" ? read.pr_number : void 0;
-}
-function to_unreadable_error(branch_name, cause) {
-  return new Error(`${UNREADABLE_PULL_REQUEST_MESSAGE}: ${branch_name}`, { cause });
-}
-async function require_pr_number(branch_name) {
-  const read = await read_pr_number(branch_name);
-  if (read.kind === "read") return read.pr_number;
-  if (read.kind === "missing") throw new Error(`${NO_PULL_REQUEST_MESSAGE}: ${branch_name}`);
-  throw to_unreadable_error(branch_name, read.cause);
-}
-async function read_pull(pr_number) {
-  const json = await git_gh_exec.exec_gh_api({
-    path: git_gh_api_path.pull_api_path(String(pr_number))
-  });
-  return git_gh_pr_rest.parse_rest_pull(json);
-}
-async function read_remembered_pull(pr_number) {
-  const pending = pull_by_number.get(pr_number) ?? read_pull(pr_number);
-  pull_by_number.set(pr_number, pending);
-  try {
-    return await pending;
-  } catch (error) {
-    if (pull_by_number.get(pr_number) === pending) pull_by_number.delete(pr_number);
-    throw error;
-  }
-}
-async function read_pull_of_branch(branch_name, read = read_remembered_pull) {
-  const number_read = await read_pr_number(branch_name);
-  if (number_read.kind !== "read") return number_read;
-  try {
-    return { kind: "read", pull: await read(number_read.pr_number) };
-  } catch (error) {
-    return { kind: "unreadable", cause: error };
-  }
-}
-async function read_pull_or_undefined(branch_name) {
-  const read = await read_pull_of_branch(branch_name);
-  return read.kind === "read" ? read.pull : void 0;
-}
-async function pr_exists(branch_name) {
-  const read = await read_pr_number(branch_name);
-  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
-  return read.kind === "read";
-}
-async function pr_get_number(branch_name) {
-  return await resolve_pr_number(branch_name);
-}
-async function pr_get_url(branch_name) {
-  const pull = await read_pull_or_undefined(branch_name);
-  if (pull?.html_url === void 0) return void 0;
-  return git_gh_helpers.parse_pr_state_string(pull.html_url);
-}
-async function pr_get_merge_state(branch_name) {
-  const read = await read_pull_of_branch(branch_name, read_pull);
-  if (read.kind !== "read") return void 0;
-  const { pull } = read;
-  return {
-    is_merged: git_gh_pr_rest.is_merged(pull),
-    merged_at: pull.merged_at ?? void 0,
-    head_sha: pull.head?.sha,
-    merge_state_status: to_gh_state(pull.mergeable_state)
-  };
-}
-async function pr_get_body(branch_name) {
-  const pull = await read_pull_or_undefined(branch_name);
-  const body = pull?.body;
-  return typeof body === "string" && body.length > 0 ? body : void 0;
-}
-async function pr_view(branch_name) {
-  const read = await read_pull_of_branch(branch_name, read_pull);
-  if (read.kind === "unreadable") throw to_unreadable_error(branch_name, read.cause);
-  if (read.kind === "missing") return "";
-  return JSON.stringify(git_gh_pr_rest.to_pr_info(read.pull));
-}
-async function read_comments(branch_name, to_path, to_json) {
-  const pr_number = await resolve_pr_number(branch_name);
-  if (pr_number === void 0) return void 0;
-  const path6 = `${to_path(String(pr_number))}${COMMENTS_QUERY}`;
-  try {
-    return to_json(await git_gh_exec.exec_gh_api({ path: path6, should_paginate: true }));
-  } catch {
-    return void 0;
-  }
-}
-function to_comments_json(raw) {
-  return JSON.stringify(git_gh_pr_rest.to_pr_comments(raw));
-}
-function as_served(raw) {
-  return raw;
-}
-async function pr_get_comments(branch_name) {
-  return await read_comments(branch_name, git_gh_api_path.issue_comments_api_path, to_comments_json);
-}
-async function pr_get_review_comments(branch_name) {
-  return await read_comments(branch_name, git_gh_api_path.pull_comments_api_path, as_served);
-}
-var git_gh_pr_read = {
-  pr_exists,
-  pr_get_number,
-  pr_get_url,
-  pr_get_body,
-  pr_get_merge_state,
-  pr_view,
-  pr_get_comments,
-  pr_get_review_comments
-};
-
-// scripts/lane/lane-registry.ts
-import { existsSync as existsSync2, statSync as statSync2 } from "node:fs";
-import path2 from "node:path";
-
-// scripts/lane/lane-environment.ts
-var LANE_OUTPUT_KEY = "JOSH_LANE_OUTPUT";
-var LANE_PROVIDER_KEY = "JOSH_LANE_AGENT_PROVIDER";
-var LANE_ROLE_KEY = "JOSH_LANE_AGENT_ROLE";
-var LANE_MODEL_KEY = "JOSH_LANE_AGENT_MODEL";
-var LANE_EFFORT_KEY = "JOSH_LANE_AGENT_EFFORT";
-var ASSIGNMENT_SEPARATOR = "=";
-var EXPORT_PREFIX = "export ";
-var QUOTE_CHARACTERS = /* @__PURE__ */ new Set(['"', "'"]);
-var MIN_QUOTED_LENGTH = 2;
-var FIRST_CHARACTER_END = 1;
-var LAST_CHARACTER_START = -1;
-function strip_export(line) {
-  const trimmed = line.trimStart();
-  return trimmed.startsWith(EXPORT_PREFIX) ? trimmed.slice(EXPORT_PREFIX.length).trimStart() : trimmed;
-}
-function is_key_line(line, key) {
-  const body = strip_export(line);
-  if (!body.startsWith(key)) return false;
-  return body.slice(key.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR);
-}
-function is_seat_line(line) {
-  return is_key_line(line, LANE_SEAT_KEY);
-}
-function is_output_line(line) {
-  return is_key_line(line, LANE_OUTPUT_KEY);
-}
-function split_lines(content) {
-  const trimmed = content.trimEnd();
-  return trimmed.length === 0 ? [] : trimmed.split("\n");
-}
-function is_quoted(raw) {
-  const first = raw.slice(0, FIRST_CHARACTER_END);
-  if (!QUOTE_CHARACTERS.has(first)) return false;
-  return raw.length >= MIN_QUOTED_LENGTH && raw.endsWith(first);
-}
-function unquote(raw) {
-  return is_quoted(raw) ? raw.slice(FIRST_CHARACTER_END, LAST_CHARACTER_START) : raw;
-}
-function assignment_value(line) {
-  return unquote(line.slice(line.indexOf(ASSIGNMENT_SEPARATOR) + FIRST_CHARACTER_END).trim());
-}
-function read_assignment(content, key) {
-  const line = split_lines(content).findLast((entry) => is_key_line(entry, key));
-  return line === void 0 ? void 0 : assignment_value(line);
-}
-function read_root_seed(content) {
-  return ports.resolve_seed({ [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY) });
-}
-function read_lane_seat(content) {
-  const raw = read_assignment(content, LANE_SEAT_KEY);
-  return raw === void 0 ? void 0 : ports.resolve_lane({ [LANE_SEAT_KEY]: raw });
-}
-function read_lane_ports(content) {
-  const environment3 = {
-    [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY),
-    [LANE_SEAT_KEY]: read_assignment(content, LANE_SEAT_KEY)
-  };
-  return {
-    development: ports.resolve_development_port(environment3),
-    preview: ports.resolve_preview_port(environment3)
-  };
-}
-function read_lane_output(content) {
-  const line = split_lines(content).findLast((entry) => is_output_line(entry));
-  const raw = line === void 0 ? void 0 : assignment_value(line);
-  return raw === void 0 || raw.length === 0 ? void 0 : raw;
-}
-function read_lane_profile(content) {
-  return agent_role_profile.parse({
-    provider: read_assignment(content, LANE_PROVIDER_KEY),
-    role: read_assignment(content, LANE_ROLE_KEY),
-    model: read_assignment(content, LANE_MODEL_KEY),
-    effort: read_assignment(content, LANE_EFFORT_KEY)
-  });
-}
-function replace_assignment(lines, keep, assignment, key) {
-  return lines.flatMap((entry, index) => {
-    if (index === keep) return [assignment];
-    if (is_key_line(entry, key)) return [];
-    return [entry];
-  });
-}
-function upsert_assignment(content, key, value) {
-  const assignment = `${key}${ASSIGNMENT_SEPARATOR}${value}`;
-  const lines = split_lines(content);
-  const last = lines.findLastIndex((entry) => is_key_line(entry, key));
-  const body = last === -1 ? [...lines, assignment] : replace_assignment(lines, last, assignment, key);
-  return `${body.join("\n")}
-`;
-}
-function lane_file_content(root_content, seat) {
-  return upsert_assignment(root_content, LANE_SEAT_KEY, String(seat));
-}
-function with_lane_output(content, output, profile) {
-  const recorded = upsert_assignment(content, LANE_OUTPUT_KEY, `"${output}"`);
-  if (profile === void 0) return recorded;
-  const with_provider = upsert_assignment(recorded, LANE_PROVIDER_KEY, profile.provider);
-  const with_role = upsert_assignment(with_provider, LANE_ROLE_KEY, profile.role);
-  const with_model = upsert_assignment(with_role, LANE_MODEL_KEY, profile.model);
-  return upsert_assignment(with_model, LANE_EFFORT_KEY, profile.effort);
-}
-var lane_environment = {
-  is_seat_line,
-  lane_file_content,
-  read_lane_output,
-  read_lane_profile,
-  read_lane_ports,
-  read_lane_seat,
-  read_root_seed,
-  with_lane_output
-};
-
-// scripts/lane/lane-registry.ts
-var WORKTREE_PREFIX = "worktree ";
-var BRANCH_PREFIX = "branch refs/heads/";
-var BLOCK_SEPARATOR = "\n\n";
-function line_value(lines, prefix) {
-  return lines.find((line) => line.startsWith(prefix))?.slice(prefix.length);
-}
-function seat_from_content(content) {
-  const seat = lane_environment.read_lane_seat(content);
-  if (seat === void 0) return void 0;
-  const port_pair = lane_environment.read_lane_ports(content);
-  return { seat, development_port: port_pair.development, preview_port: port_pair.preview };
-}
-var EMPTY_SEAT = {
-  seat: void 0,
-  development_port: void 0,
-  preview_port: void 0
-};
-function held_seat(content) {
-  if (content === void 0) return EMPTY_SEAT;
-  return seat_from_content(content) ?? EMPTY_SEAT;
-}
-function read_environment(directory) {
-  return file_reader.read_if_readable(path2.join(directory, ENV_FILE_NAME));
-}
-function dispatched_at(directory) {
-  return statSync2(path2.join(directory, ENV_FILE_NAME), { throwIfNoEntry: false })?.mtimeMs;
-}
-function branch_issue(branch) {
-  if (!branch?.endsWith(lane_paths.LANE_BRANCH_SUFFIX)) return void 0;
-  const issue2 = branch.slice(0, -lane_paths.LANE_BRANCH_SUFFIX.length);
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue2) ? issue2 : void 0;
-}
-function is_gone(directory) {
-  return !existsSync2(directory);
-}
-function build_lane(issue2, branch, directory, is_stranded) {
-  const content = is_stranded ? void 0 : read_environment(directory);
-  const held = held_seat(content);
-  const output = content === void 0 ? void 0 : lane_environment.read_lane_output(content);
-  const profile = content === void 0 ? void 0 : lane_environment.read_lane_profile(content);
-  return {
-    issue: issue2,
-    branch,
-    directory,
-    seat: held.seat,
-    development_port: held.development_port,
-    preview_port: held.preview_port,
-    output,
-    profile,
-    dispatched_ms: is_stranded ? void 0 : dispatched_at(directory),
-    is_stranded
-  };
-}
-function is_lane_directory(root, issue2, directory) {
-  return directory === lane_paths.lane_directory(root, issue2);
-}
-function parse_block(block, root) {
-  const lines = block.split("\n");
-  const directory = line_value(lines, WORKTREE_PREFIX);
-  const branch = line_value(lines, BRANCH_PREFIX);
-  const issue2 = branch_issue(branch);
-  if (directory === void 0 || branch === void 0 || issue2 === void 0 || !is_lane_directory(root, issue2, directory)) {
-    return void 0;
-  }
-  return build_lane(issue2, branch, directory, is_gone(directory));
-}
-function is_lane(lane) {
-  return lane !== void 0;
-}
-async function worktree_blocks() {
-  const listing = await git_worktree.worktree_list();
-  return listing.split(BLOCK_SEPARATOR);
-}
-async function main_repository_root() {
-  return repo_discovery.main_worktree(await git_command.repository_root());
-}
-async function list_lanes() {
-  const root = lane_paths.lane_root(await main_repository_root());
-  const blocks = await worktree_blocks();
-  const lanes = blocks.map((block) => parse_block(block, root)).filter(is_lane);
-  return lanes.toSorted((left, right) => Number(left.issue) - Number(right.issue));
-}
-async function registered_directories() {
-  const blocks = await worktree_blocks();
-  return blocks.flatMap((block) => line_value(block.split("\n"), WORKTREE_PREFIX) ?? []);
-}
-async function has_lanes_in_flight() {
-  const lanes = await list_lanes();
-  return lanes.some((lane) => !lane.is_stranded);
-}
-function used_seats(lanes) {
-  return lanes.map((lane) => lane.seat).filter((seat) => seat !== void 0);
-}
-function unreadable_lanes(lanes) {
-  return lanes.filter((lane) => !lane.is_stranded && lane.seat === void 0);
-}
-function find_lane(lanes, issue2) {
-  return lanes.find((lane) => lane.issue === issue2);
-}
-async function find_open_lane(issue2) {
-  return find_lane(await list_lanes(), issue2);
-}
-var lane_registry = {
-  find_lane,
-  find_open_lane,
-  has_lanes_in_flight,
-  list_lanes,
-  main_repository_root,
-  parse_block,
-  read_environment,
-  registered_directories,
-  unreadable_lanes,
-  used_seats
-};
-
-// scripts/run/run-preflight.ts
-import { z as z5 } from "zod";
-var CLEAN_VERDICT = "clean";
-var RECLAIM_VERDICT = "reclaim";
-var RESUME_VERDICT = "resume";
-var PARK_VERDICT = "park";
-var NO_PR = "none";
-var OPEN_PR = "open";
-var MERGED_PR = "merged";
-var CLOSED_PR = "closed";
-var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
-var pr_info_schema = z5.object({ state: z5.string().optional() });
-var GH_PR_STATES = /* @__PURE__ */ new Map([
-  ["CLOSED", CLOSED_PR],
-  ["MERGED", MERGED_PR],
-  ["OPEN", OPEN_PR]
-]);
-var CLEAN_REASON = "Nothing was left behind: the tree is clean, HEAD is on the default branch, and this issue has no pull request and no branch holding work.";
-var CLEAN_ADVICE = "Start the child.";
-var RESUME_ADVICE = "Reuse the branch and run the whole verification gate from the start \u2014 refactor, `pnpm josh gate`, `/code-review` \u2014 never only the part the interrupted run had not reached. Nobody verified what it already committed.";
-var PARK_ADVICE = "Park the child: add `needs-decision` and comment what was found. Do not delete the branch, do not reopen the pull request, and do not commit on top of it.";
-var STASH_LABEL_PREFIX = "run:hold reclaimed before #";
-var { require_issue_number } = issue_number_shape;
-var UNREADABLE_PR_MESSAGE = "The pull request could not be read for branch ";
-function needs_reclaim(tree) {
-  return tree.is_dirty || tree.branch !== tree.default_branch;
-}
-function is_pr_decided(state) {
-  return state === MERGED_PR || state === CLOSED_PR;
-}
-function has_leftover_work(child) {
-  return child.branch_name !== void 0 || child.pr_state === OPEN_PR;
-}
-function to_verdict(tree, child) {
-  if (needs_reclaim(tree)) return RECLAIM_VERDICT;
-  if (is_pr_decided(child.pr_state)) return PARK_VERDICT;
-  if (has_leftover_work(child)) return RESUME_VERDICT;
-  return CLEAN_VERDICT;
-}
-function reclaim_reason(tree) {
-  const findings = [
-    tree.is_dirty ? "uncommitted changes" : void 0,
-    tree.branch === tree.default_branch ? void 0 : `HEAD on ${tree.branch}`
-  ].filter((entry) => entry !== void 0);
-  return `An earlier run left ${findings.join(" and ")} in this working tree.`;
-}
-function park_reason(state) {
-  return `The pull request for this issue is ${state}, so whether any work is still owed is a person's call.`;
-}
-function resume_reason(child) {
-  const branch_part = child.branch_name === void 0 ? "" : ` on branch ${child.branch_name}`;
-  const pr_part = child.pr_state === OPEN_PR ? ", and its pull request is still open" : "";
-  return `An earlier run left a partial implementation${branch_part}${pr_part}.`;
-}
-function to_reason(verdict, tree, child) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_reason(tree);
-  if (verdict === PARK_VERDICT) return park_reason(child.pr_state);
-  if (verdict === RESUME_VERDICT) return resume_reason(child);
-  return CLEAN_REASON;
-}
-function reclaim_steps(tree, issue2) {
-  if (!tree.is_dirty) return [];
-  return [
-    `git stash push -u -m "${STASH_LABEL_PREFIX}${issue2}"`,
-    `Record the stash on ${session_cite.issue(issue2)} \u2014 the comment is what gets it popped; nothing pops it for you.`
-  ];
-}
-function reclaim_advice(tree, issue2) {
-  return [
-    ...reclaim_steps(tree, issue2),
-    "pnpm josh ms",
-    "Then ask this command again: it is re-askable, and the clean tree gets its own answer."
-  ].join("\n");
-}
-function to_advice(verdict, issue2, tree) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_advice(tree, issue2);
-  if (verdict === RESUME_VERDICT) return RESUME_ADVICE;
-  if (verdict === PARK_VERDICT) return PARK_ADVICE;
-  return CLEAN_ADVICE;
-}
-function decide(tree, child, issue2) {
-  const verdict = to_verdict(tree, child);
-  return {
-    advice: to_advice(verdict, issue2, tree),
-    reason: to_reason(verdict, tree, child),
-    verdict
-  };
-}
-function read_pr_field(raw) {
-  return json_value.parse_with(raw, pr_info_schema)?.state;
-}
-function to_pr_state2(raw) {
-  const state = read_pr_field(raw);
-  return (state === void 0 ? void 0 : GH_PR_STATES.get(state)) ?? NO_PR;
-}
-async function read_tree_state() {
-  const [is_dirty, current, default_branch] = await Promise.all([
-    run_hold.is_tree_dirty(),
-    git_command.branch(),
-    git_command.get_default_branch()
-  ]);
-  return { branch: current, default_branch, is_dirty };
-}
-async function read_pr_state(branch_name) {
-  if (!await git_gh_pr_read.pr_exists(branch_name)) return NO_PR;
-  const raw = await git_gh_pr_read.pr_view(branch_name);
-  if (raw === "") throw new Error(`${UNREADABLE_PR_MESSAGE}${branch_name}`);
-  return to_pr_state2(raw);
-}
-function is_pr_open(state) {
-  return state === OPEN_PR;
-}
-async function read_pr_of_branch(branch_name) {
-  return { branch_name, pr_state: await read_pr_state(branch_name) };
-}
-function pick_child_state(reads) {
-  const decided = reads.find((read) => is_pr_decided(read.pr_state));
-  const open = reads.find((read) => is_pr_open(read.pr_state));
-  return decided ?? open ?? { branch_name: reads[0]?.branch_name, pr_state: NO_PR };
-}
-var ISSUE_BRANCH_SUFFIX = "-*";
-var ANY_REMOTE_PREFIX = "*/";
-var REMOTE_SEPARATOR = "/";
-var NOT_FOUND_INDEX = -1;
-function to_head_branch(name) {
-  const separator_index = name.indexOf(REMOTE_SEPARATOR);
-  return separator_index === NOT_FOUND_INDEX ? name : name.slice(separator_index + 1);
-}
-function group_by_head(pairs) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [name, reference2] of pairs) groups.set(name, [...groups.get(name) ?? [], reference2]);
-  return groups;
-}
-async function read_branch_candidates(issue2) {
-  const pattern = `${issue2}${ISSUE_BRANCH_SUFFIX}`;
-  const [local, remote] = await Promise.all([
-    git_command.branch_names(pattern),
-    git_command.branch_names_remote(`${ANY_REMOTE_PREFIX}${pattern}`)
-  ]);
-  return group_by_head([
-    ...local.map((name) => [name, name]),
-    ...remote.map((reference2) => [to_head_branch(reference2), reference2])
-  ]);
-}
-async function has_commits_beyond(base, references) {
-  const counts = await Promise.all(
-    references.map(async (reference2) => await git_command.commit_count_beyond(base, reference2))
-  );
-  return counts.some((count) => count > 0);
-}
-async function is_held_dirty(name, lane) {
-  if (lane?.branch !== name || lane.is_stranded) return false;
-  return await run_hold.is_tree_dirty(lane.directory);
-}
-async function read_candidate(name, references, context) {
-  const state = await read_pr_of_branch(name);
-  if (state.pr_state !== NO_PR || await has_commits_beyond(context.base, references)) return state;
-  return await is_held_dirty(name, context.lane) ? state : void 0;
-}
-async function read_child_state(issue2) {
-  const candidates = await read_branch_candidates(issue2);
-  if (candidates.size === 0) return NO_CHILD_WORK;
-  const [base, lane] = await Promise.all([
-    git_command.default_branch_reference(),
-    lane_registry.find_open_lane(issue2)
-  ]);
-  const reads = await Promise.all(
-    [...candidates].map(
-      async ([name, references]) => await read_candidate(name, references, { base, lane })
-    )
-  );
-  return pick_child_state(reads.filter((read) => read !== void 0));
-}
-async function check(issue2) {
-  require_issue_number(issue2);
-  const tree = await read_tree_state();
-  if (needs_reclaim(tree)) return decide(tree, NO_CHILD_WORK, issue2);
-  return decide(tree, await read_child_state(issue2), issue2);
-}
-var run_preflight = {
-  CLEAN_VERDICT,
-  RESUME_ADVICE,
-  MERGED_PR,
-  STASH_LABEL_PREFIX,
-  check,
-  decide,
-  read_child_state,
-  read_pr_state,
-  to_pr_state: to_pr_state2
-};
-
-// scripts/run/ship/run-ship-probe.ts
-var REPOSITORY_DIRECTORY_INDEX = 1;
-var REMOTE_SHA_INDEX = 0;
-var REMOTE_FIELD_SEPARATOR = /\s/u;
-var HEAD_REFERENCE = "HEAD";
-async function or_false(is_true) {
-  try {
-    return await is_true();
-  } catch (error) {
-    error_text.trace_swallowed("run_ship_probe.or_false", error);
-    return false;
-  }
-}
-async function read_committed() {
-  if (await run_hold.is_tree_dirty()) return false;
-  const base = await git_command.default_branch_reference();
-  return await git_command.commit_count_beyond(base, HEAD_REFERENCE) > 0;
-}
-async function read_pushed(branch_name) {
-  const [remote, head] = await Promise.all([
-    git_worktree.ls_remote_branch(branch_name),
-    git_command.head_commit()
-  ]);
-  return remote.split(REMOTE_FIELD_SEPARATOR)[REMOTE_SHA_INDEX] === head;
-}
-async function read_merged(branch_name) {
-  if (await run_preflight.read_pr_state(branch_name) !== run_preflight.MERGED_PR) return false;
-  const base = await git_command.default_branch_reference();
-  return await git_command.commit_count_beyond(base, HEAD_REFERENCE) === 0;
-}
-var NOTHING_DONE = { is_committed: false, is_pushed: false, is_merged: false };
-async function read_branch_state(branch_name) {
-  const [is_committed, is_pushed, is_merged2] = await Promise.all([
-    or_false(read_committed),
-    or_false(async () => await read_pushed(branch_name)),
-    or_false(async () => await read_merged(branch_name))
-  ]);
-  return { is_committed, is_pushed, is_merged: is_merged2 };
-}
-async function read_state() {
-  try {
-    return await read_branch_state(await git_command.branch());
-  } catch {
-    return NOTHING_DONE;
-  }
-}
-async function repository_directory() {
-  try {
-    const directories2 = await git_command.git_directories();
-    return directories2[REPOSITORY_DIRECTORY_INDEX];
-  } catch {
-    return void 0;
-  }
-}
-async function record_target(issue2) {
-  const repository2 = await repository_directory();
-  return repository2 === void 0 ? void 0 : run_ship_stage.record_path(repository2, issue2);
-}
-var run_ship_probe = { read_state, record_target, repository_directory };
-
-// scripts/run/ship/run-ship-stop-context.ts
-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_SEPARATOR = "-";
-var LINE_BREAK = "\n";
-var CARRIAGE_RETURN = "\r";
-var omitted_schema = z6.object({ path: z6.string().optional(), last_line: z6.number().int() }).strict();
-var stop_context_schema = z6.object({
-  excerpt: z6.array(z6.string()).readonly(),
-  omitted: omitted_schema.optional(),
-  changed: z6.array(z6.string()).readonly().optional(),
-  more_changed: z6.number().int()
-}).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_role_profile.printable(shown_frame(line)));
-}
-async function keep_full_output(issue2, output) {
-  const repository2 = await run_ship_probe.repository_directory();
-  if (repository2 === void 0) return void 0;
-  const target = stamp_file.stamp_path(
-    `${OUTPUT_PREFIX}${issue2}${KEY_SEPARATOR}`,
-    repository2,
-    OUTPUT_SUFFIX
-  );
-  try {
-    return stamp_file.replace_text_stamp(target, output);
-  } catch {
-    return void 0;
-  }
-}
-async function omitted_range(issue2, lines) {
-  const path6 = await keep_full_output(issue2, lines.join(LINE_BREAK));
-  const last_line = lines.length - EXCERPT_LINE_LIMIT;
-  return path6 === void 0 ? { last_line } : { path: path6, last_line };
-}
-function clipped(lines) {
-  return lines.map((line) => line.slice(0, EXCERPT_LINE_WIDTH));
-}
-async function excerpt_of(issue2, 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(issue2, 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(issue2, output) {
-  return { ...await excerpt_of(issue2, output), ...await changed_of() };
-}
-function has_excerpt(context) {
-  return context !== void 0 && context.excerpt.length > 0;
-}
-function excerpt_heading(issue2, omitted, shown) {
-  if (omitted === void 0) return "The failed stage output:";
-  const source = omitted.path ?? `the stopped report (\`${run_ship_next.COMMAND.LOG} ${issue2}\`)`;
-  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(issue2, context, changed, dropped) {
-  const shown = context.excerpt.slice(dropped);
-  const heading = excerpt_heading(issue2, 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 describe(issue2, context, budget = agent_role_profile.MAX_VALUE_LENGTH) {
-  const changed = changed_text(context);
-  if (!has_excerpt(context)) return changed;
-  let dropped = 0;
-  let block = excerpt_block(issue2, context, changed, dropped);
-  while (block.length > budget && dropped < context.excerpt.length - 1) {
-    dropped += 1;
-    block = excerpt_block(issue2, context, changed, dropped);
-  }
-  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(issue2) {
-  issue_number_shape.require_issue_number(issue2);
-  return `${CHILD_INVOCATION} ${issue_cite.plain(issue2)}`;
-}
-function process_pattern(issue2) {
-  issue_number_shape.require_issue_number(issue2);
-  return `(${CHILD_INVOCATION}|${REVIEW_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue2)}$`;
-}
-function review_invocation(issue2) {
-  issue_number_shape.require_issue_number(issue2);
-  return `${REVIEW_INVOCATION} ${issue_cite.plain(issue2)}`;
-}
-function resume_invocation(issue2) {
-  const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue2)} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:cut --resume ${issue2}\` 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(issue2)}`;
-}
-function outage_resume_invocation(issue2) {
-  const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue2)} 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 ${issue2}\` to find the next action, redoing only the last step if it did not complete.`;
-  return `${preamble} ${child_invocation(issue2)}`;
-}
-function known_stop_lines(issue2, stop, frame) {
-  const { context } = stop;
-  const is_excerpted = run_ship_stop_context.has_excerpt(context);
-  const next = run_ship_next.next_step(issue2, 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_role_profile.MAX_VALUE_LENGTH - fixed;
-  return [next, run_ship_stop_context.describe(issue2, context, budget)];
-}
-function ship_stop_invocation(issue2, stop) {
-  const opening = `Resuming the lane child for issue ${issue_cite.plain(issue2)} 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(issue2)}`;
-  const middle = stop === void 0 ? [
-    `Run \`pnpm josh run:step ${issue2}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.`
-  ] : known_stop_lines(issue2, stop, [opening, closing]);
-  return [opening, ...middle, closing].join(LINE_BREAK2);
-}
-var lane_child_invocation = {
-  child_invocation,
-  outage_resume_invocation,
-  process_pattern,
-  resume_invocation,
-  review_invocation,
-  ship_stop_invocation
-};
-
-// scripts/lane/process-tools.ts
-import path3 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 `\`${path3.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 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 execFileSync2(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 terminate(pid) {
-  try {
-    process.kill(pid, TERMINATE_SIGNAL);
-    return true;
-  } catch {
-    return false;
-  }
-}
-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) {
-  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(issue2, own2, probes) {
-  const pattern = lane_child_invocation.process_pattern(issue2);
-  return probes.matching(pattern).filter((pid) => !own2.has(pid));
-}
-function reap_child(issue2, probes = SYSTEM_PROBES) {
-  const own2 = own_ancestry(probes);
-  const doomed = tree_of(roots_of(issue2, own2, probes), probes).filter((pid) => !own2.has(pid));
-  return doomed.filter((pid) => probes.terminate(pid));
-}
-function is_child_running(issue2, probes = SYSTEM_PROBES) {
-  return roots_of(issue2, own_ancestry(probes), probes).length > 0;
-}
-var lane_reap = {
-  is_child_running,
-  own_ancestry,
-  parse_pids,
-  reap_child
-};
-
-// scripts/run/run-headless.ts
-var HEADLESS_ENV_KEY = "JOSH_RUN_HEADLESS";
-var HEADLESS_VALUE = "1";
-function environment2() {
-  return { [HEADLESS_ENV_KEY]: HEADLESS_VALUE };
-}
-function is_headless2(source = process.env) {
-  return source[HEADLESS_ENV_KEY] === HEADLESS_VALUE;
-}
-function is_headless_parent(source) {
-  return is_headless2(source) && lane_child_marker.marked_issue(source) === void 0;
-}
-function is_cut_capped(carry, source = process.env) {
-  return !is_headless_parent(source) && run_carry.is_at_cut_cap(carry);
-}
-function is_driving(read) {
-  return read?.kind === "carried" && read.carry.is_handed_off !== true;
-}
-async function read_carry_here() {
-  const repository2 = await run_carry.repository_directory();
-  return repository2 === void 0 ? void 0 : run_carry.read_carry(run_carry.carry_path(repository2));
-}
-async function must_keep_waiting(source = process.env) {
-  if (!is_headless_parent(source) || !await lane_registry.has_lanes_in_flight()) return false;
-  return is_driving(await read_carry_here());
-}
-async function current_carry() {
-  const read = await read_carry_here();
-  return read?.kind === "carried" ? read.carry : void 0;
-}
-function is_owned_here(carry, ancestry) {
-  return carry.owner_pid !== void 0 && ancestry().has(carry.owner_pid);
-}
-function driven_here(read, ancestry) {
-  if (read?.kind !== "carried" || !is_driving(read)) return void 0;
-  return is_owned_here(read.carry, ancestry) ? read.carry : void 0;
-}
-async function driving_carry(source = process.env, ancestry = lane_reap.own_ancestry) {
-  if (lane_child_marker.marked_issue(source) !== void 0) return void 0;
-  return driven_here(await read_carry_here(), ancestry);
-}
-async function is_backlog_parent(source = process.env, ancestry = lane_reap.own_ancestry) {
-  return await driving_carry(source, ancestry) !== void 0;
-}
-var run_headless = {
-  HEADLESS_ENV_KEY,
-  current_carry,
-  driven_here,
-  driving_carry,
-  environment: environment2,
-  is_backlog_parent,
-  is_cut_capped,
-  is_headless: is_headless2,
-  is_headless_parent,
-  is_owned_here,
-  must_keep_waiting
-};
-
-// scripts/run/event/run-event-stream.ts
-import { z as z7 } from "zod";
-var EVENT_PREFIX = "josh-run-events-";
-var EVENT_SUFFIX = ".jsonl";
-var EVENT_CAP = 500;
-var FIRST_POSITION = 0;
-var POSITION_INCREMENT = 1;
-var LINE_SEPARATOR = "\n";
-var WORD_SEPARATOR2 = " ";
-var STAGE_PHASE_INDEX = 2;
-var LOCK_SUFFIX = ".lock";
-var LOCK_WAIT_MS = 5e3;
-var EVENT_KIND = {
-  PLAN: "plan",
-  CHILD_LAUNCH: "child-launch",
-  MERGE: "merge",
-  PARK: "park",
-  SPLIT: "split",
-  OUTAGE: "outage",
-  CUT: "cut",
-  // A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`. The
-  // resume clears the cut record, so without this the `cut` would stay the newest position and
-  // `run:step` would keep answering the resume command it had just run.
-  RESUME: "resume",
-  // A person stopped a running lane child and re-dispatched its issue in a fresh session
-  // (`lane:restart`). It follows the fresh dispatch's `CHILD_LAUNCH`, so it is a launch to the parent and
-  // the board, and — like that launch — a batch record a lane child never reads as its own position.
-  RESTART: "restart",
-  // A person withdrew a lane child — stopped it and closed its issue as not planned (`lane:withdraw`).
-  // It is written before the stop, so `run:merge` settles the child as withdrawn whatever GitHub says
-  // by the time the parent collects it, and counts it as neither a merge, a failure nor an outage.
-  WITHDRAW: "withdraw",
-  // The backlog emptied while nothing of the run's own was in flight — the drain. It marks the position
-  // at which the end-of-run retrospective is owed, *before* the idle watch opens, so `run:step` fires
-  // the retrospective at the drain rather than after the watch runs its course. It is not itself a
-  // stop: the run watches on once the retrospective has run, and the real `STOP` follows when the watch
-  // expires.
-  DRAIN: "drain",
-  STOP: "stop",
-  PR_OPENED: "pr-opened",
-  REVIEW_ROUND: "review-round",
-  // The end-of-run retrospective's result, recorded when the run marks the retrospective done. A
-  // retrospective that files zero improvements and one that never ran look
-  // the same from outside — no new Issue either way — so the result is put on the stream the report is
-  // generated from: the issues filed (or that none were), and the candidates dropped with why. It is
-  // emitted from the `run:carry --retrospective` close, so marking the retrospective done and recording
-  // what it found are one action rather than two the run could do only one of.
-  RETROSPECTIVE: "retrospective",
-  // Ready backlog work is sitting undispatched while a lane is free and nothing has dispatched for a
-  // while. Emitted once per stall episode by the stop-time detector, it is both the dedup marker —
-  // `emit_once_since` refuses a second until a `CHILD_LAUNCH` intervenes — and the line a terminal
-  // reader following the stream sees. `run:step` reads it as `backlog:next`, so a run that
-  // stalled is pointed straight at dispatching the work rather than left waiting.
-  STALL: "stall",
-  // The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
-  // is watching. Emitted once per strand episode by the stop-time detector — or by the `run:wake`
-  // supervisor as it fails, leaves that state behind and has warned of it —
-  // exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
-  // than once, and a terminal reader following the stream sees the line. The strand is the step before
-  // the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
-  STRANDED: "stranded",
-  // One `josh ship` stage starting, succeeding or failing. It is a trace of the
-  // composite's progress rather than a position the run is at — the positions a ship leaves behind are
-  // the closed issue its `followup` merges, or a detached supervisor's `SHIP_LAUNCH` / `SHIP_STOP` below
-  // — so it is one of the `TRACE_KINDS` the last-event read skips.
-  SHIP_STAGE: "ship-stage",
-  // One progress watcher line — the `at … / next …` heartbeat `run:progress` prints. Printed only to
-  // the watcher's own output, a headless successor's heartbeat would be buried in its log after a cut;
-  // on the stream it reaches the attached session's relay. It says
-  // the run is alive rather than where it is, so it is a trace kind like `SHIP_STAGE`.
-  HEARTBEAT: "heartbeat",
-  // The post-implementation region handed to a detached `josh ship --detach` supervisor. Unlike a stage
-  // trace it is a position: the agent has ended and the
-  // supervisor carries the run, so `run:step` answers `wait` until it stops or the issue closes.
-  SHIP_LAUNCH: "ship-launch",
-  // The supervisor stopped at a failed stage — a red gate, a High/Medium review, a failed push, red CI
-  // The position that hands control back: `run:step` prints the command that
-  // shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
-  SHIP_STOP: "ship-stop",
-  // An Issue the run filed on its way, written by `issue:file`, so a run started from the command line
-  // still surfaces what it found — `run:board`'s findings section reads it.
-  FILED: "filed",
-  // A one-line observation short of an Issue, written with `run:event --append note` and shown in the
-  // same section.
-  NOTE: "note",
-  // A lane child reached a phase no other event marks — its first implementation edit, written by the
-  // PreToolUse hook — so `run:board` draws how far the child has got. A trace,
-  // like `SHIP_STAGE`: it says where the child's work is, not where the run is.
-  LANE_PHASE: "lane-phase",
-  // An issue `run:add` put into the live run. The parent's `--wait` watcher
-  // ends on it, so the issue takes the next free lane without waiting out the arrival probe's minute. A
-  // trace: it says what the run was handed, not where the run is.
-  ADD: "add",
-  // `josh lane:limit` raised a live run's lane limit. The `--wait` watcher's
-  // arrival probe reads it as a wake: the lanes a raise frees are new room for a pool its baseline
-  // already holds. A trace: it says the run gained room, not where the run is.
-  LANE_LIMIT: "lane-limit",
-  // One stage of the run's start — the session starting, the plan, the hand-off to the supervisor, a
-  // lane opening (`run-event-setup.ts`). `run:board` draws it while the run stands at it, so the
-  // minutes before one read as work rather than as a run that has stopped. A trace: it says the run is
-  // getting ready, not where the run is.
-  SETUP: "setup",
-  // A child's pull request checks as `josh followup` last polled them — the CI counts and CodeRabbit's
-  // state (`run-event-checks.ts`), written only when they change, so `run:board` draws a child waiting
-  // in followup without asking GitHub (joshuafolkken/kit#3770). A trace: it says how the checks stand,
-  // not where the run is.
-  PR_CHECKS: "pr-checks"
-};
-var EVENT_KINDS = Object.values(EVENT_KIND);
-var TRACE_KINDS = /* @__PURE__ */ new Set([
-  EVENT_KIND.SHIP_STAGE,
-  EVENT_KIND.HEARTBEAT,
-  EVENT_KIND.FILED,
-  EVENT_KIND.NOTE,
-  EVENT_KIND.LANE_PHASE,
-  EVENT_KIND.ADD,
-  EVENT_KIND.LANE_LIMIT,
-  EVENT_KIND.SETUP,
-  EVENT_KIND.PR_CHECKS
-]);
-var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
-  EVENT_KIND.SHIP_STAGE,
-  EVENT_KIND.HEARTBEAT,
-  EVENT_KIND.SETUP,
-  EVENT_KIND.PR_CHECKS
-]);
-var event_schema = z7.object({
-  pos: z7.number(),
-  at: z7.string(),
-  kind: z7.string(),
-  text: z7.string()
-});
-function is_event_kind(value) {
-  return EVENT_KINDS.includes(value);
-}
-function target_of(repository2) {
-  return stamp_file.stamp_path(EVENT_PREFIX, repository2, EVENT_SUFFIX);
-}
-function is_present(event) {
-  return event !== void 0;
-}
-function parse_line(line) {
-  return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
-}
-function read_lines(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return [];
-  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line(line)).filter(is_present);
-}
-function read_events(target) {
-  return read_lines(target).filter((event) => is_event_kind(event.kind));
-}
-function last_position(events) {
-  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
-}
-function issue_of(event) {
-  return event.text.split(WORD_SEPARATOR2)[FIRST_POSITION] ?? "";
-}
-function newest_by_issue(events, kind) {
-  const newest = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    if (event.kind === kind) newest.set(issue_of(event), event);
-  }
-  return new Set(newest.values());
-}
-function is_stage_start(event) {
-  if (event.kind !== EVENT_KIND.SHIP_STAGE) return false;
-  return event.text.split(WORD_SEPARATOR2)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START;
-}
-function drawn_lines(events) {
-  const setup = events.findLast((event) => event.kind === EVENT_KIND.SETUP);
-  return /* @__PURE__ */ new Set([
-    ...newest_by_issue(events, EVENT_KIND.SHIP_STAGE),
-    ...newest_by_issue(events, EVENT_KIND.PR_CHECKS),
-    ...setup === void 0 ? [] : [setup]
-  ]);
-}
-function droppable(events) {
-  const kept = drawn_lines(events);
-  const disposable = events.filter((event) => DISPOSABLE_KINDS.has(event.kind) && !kept.has(event));
-  return [
-    ...disposable.filter((event) => !is_stage_start(event)),
-    ...disposable.filter((event) => is_stage_start(event))
-  ];
-}
-function bounded(events) {
-  const excess = events.length - EVENT_CAP;
-  if (excess <= 0) return events;
-  const dropped = new Set(droppable(events).slice(0, excess));
-  return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP);
-}
-function serialize(events) {
-  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
-}
-function append_held(target, event) {
-  const position = last_position(read_lines(target)) + POSITION_INCREMENT;
-  const events = bounded([...read_events(target), { pos: position, ...event }]);
-  stamp_file.replace_text_stamp(target, serialize(events));
-  return position;
-}
-function append(target, kind, text2, at) {
-  if (!is_event_kind(kind)) return { appended: false, position: FIRST_POSITION };
-  const lock = `${target}${LOCK_SUFFIX}`;
-  const position = repository_lock.with_lock_sync(
-    () => append_held(target, { at, kind, text: text2 }),
-    lock,
-    LOCK_WAIT_MS
-  );
-  if (position === void 0) {
-    const message = `run event stream: gave up waiting for the lock at ${lock}`;
-    process.stderr.write(`${message}
-`);
-    throw new Error(message);
-  }
-  return { appended: true, position };
-}
-function read_from(target, position) {
-  const events = read_events(target);
-  return {
-    events: events.filter((event) => event.pos > position),
-    next_position: last_position(events)
-  };
-}
-function read_last(target) {
-  return read_events(target).findLast((event) => !TRACE_KINDS.has(event.kind));
-}
-function has_since(events, kind, reset_kind) {
-  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
-  return events.slice(reset_at + POSITION_INCREMENT).some((event) => event.kind === kind);
-}
-var FIELD_SEPARATOR = " \xB7 ";
-function format_event(event) {
-  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
-}
-var run_event_stream = {
-  EVENT_CAP,
-  EVENT_KIND,
-  EVENT_KINDS,
-  TRACE_KINDS,
-  append,
-  format_event,
-  has_since,
-  is_stage_start,
-  read_events,
-  read_from,
-  read_last,
-  target_of
-};
-
-// scripts/run/event/run-event-scope.ts
-var SINCE_SCOPE = "since";
-var UNKNOWN_SCOPE = "unknown";
-var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
-function moment_of(at) {
-  const parsed = Date.parse(at);
-  return Number.isNaN(parsed) ? void 0 : parsed;
-}
-function is_within(event, floor) {
-  const at = moment_of(event.at);
-  return at !== void 0 && at >= floor;
-}
-function scoped_events(events, scope) {
-  if (scope.kind === UNKNOWN_SCOPE) return void 0;
-  const floor = moment_of(scope.started_at);
-  if (floor === void 0) return void 0;
-  return events.filter((event) => is_within(event, floor));
-}
-function scope_of(read) {
-  if (read.kind !== "carried") return UNKNOWN_EVENT_SCOPE;
-  return { kind: SINCE_SCOPE, started_at: read.carry.started_at };
-}
-function last_scoped_event(events, scope) {
-  return scoped_events(events, scope)?.findLast(
-    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
-  );
-}
-var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
-  run_event_stream.EVENT_KIND.SHIP_LAUNCH,
-  run_event_stream.EVENT_KIND.SHIP_STOP
-]);
-var KIND = run_event_stream.EVENT_KIND;
-var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
-  KIND.CHILD_LAUNCH,
-  KIND.RESTART,
-  KIND.WITHDRAW,
-  KIND.PARK,
-  KIND.SPLIT,
-  KIND.RETROSPECTIVE,
-  KIND.STRANDED
-]);
-var ISSUE_REFERENCE = /#(\d+)/u;
-function is_foreign_ship_event(event, issue2) {
-  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain(issue2)} `);
-}
-function is_own_ship_event(event, issue2) {
-  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue2);
-}
-function issue_named(event) {
-  return ISSUE_REFERENCE.exec(event.text)?.[1];
-}
-function names_issue(event, issue2) {
-  return issue_named(event) === issue2;
-}
-function is_lane_position(event, issue2) {
-  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue2);
-}
-function since_own_launch(events, issue2) {
-  const launch2 = events.findLastIndex(
-    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue2)
-  );
-  return events.slice(launch2 + 1);
-}
-function is_foreign_event(event, issue2, is_lane_child) {
-  if (is_lane_child) return !is_lane_position(event, issue2);
-  return is_foreign_ship_event(event, issue2);
-}
-function last_issue_event(events, scope, issue2, is_lane_child) {
-  const attempt = is_lane_child ? since_own_launch(events, issue2) : events;
-  const own2 = attempt.filter((event) => !is_foreign_event(event, issue2, is_lane_child));
-  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own2, scope);
-  return own2.findLast((event) => is_own_ship_event(event, issue2));
-}
-var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
-  KIND.CHILD_LAUNCH,
-  KIND.MERGE,
-  KIND.PARK,
-  KIND.SPLIT,
-  KIND.WITHDRAW
-]);
-function is_merge_owed(events, scope, issue2) {
-  const newest = (scoped_events(events, scope) ?? []).findLast(
-    (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue2)
-  );
-  return newest?.kind === KIND.CHILD_LAUNCH;
-}
-function is_launch_or_withdrawal(event, issue2) {
-  const is_kind = event.kind === KIND.CHILD_LAUNCH || event.kind === KIND.WITHDRAW;
-  return is_kind && names_issue(event, issue2);
-}
-function is_withdrawn(events, issue2) {
-  const newest = events.findLast((event) => is_launch_or_withdrawal(event, issue2));
-  return newest?.kind === KIND.WITHDRAW;
-}
-var run_event_scope = {
-  UNKNOWN_EVENT_SCOPE,
-  is_merge_owed,
-  is_withdrawn,
-  issue_named,
-  last_issue_event,
-  last_scoped_event,
-  moment_of,
-  scope_of,
-  scoped_events,
-  since_own_launch
-};
-
-// scripts/run/event/run-event-stream-emit.ts
-function now_iso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-async function stream_target() {
-  const repository2 = await run_carry.repository_directory();
-  return repository2 === void 0 ? void 0 : run_event_stream.target_of(repository2);
-}
-async function emit(kind, text2) {
-  try {
-    const target = await stream_target();
-    if (target === void 0) return;
-    run_event_stream.append(target, kind, text2, now_iso());
-  } catch {
-  }
-}
-async function emit_once(kind, text2) {
-  try {
-    const target = await stream_target();
-    if (target === void 0 || run_event_stream.read_last(target)?.kind === kind) return false;
-    return run_event_stream.append(target, kind, text2, now_iso()).appended;
-  } catch (error) {
-    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
-    return false;
-  }
-}
-function invocation_events(repository2, target) {
-  const events = run_event_stream.read_events(target);
-  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository2)));
-  return run_event_scope.scoped_events(events, scope) ?? events;
-}
-async function emit_once_since(kind, text2, reset_kind) {
-  try {
-    const repository2 = await run_carry.repository_directory();
-    if (repository2 === void 0) return false;
-    const target = run_event_stream.target_of(repository2);
-    if (run_event_stream.has_since(invocation_events(repository2, target), kind, reset_kind)) {
-      return false;
-    }
-    return run_event_stream.append(target, kind, text2, now_iso()).appended;
-  } catch (error) {
-    error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
-    return false;
-  }
-}
-async function emit_heartbeat(line) {
-  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
-}
-async function scoped_current_events() {
-  try {
-    const repository2 = await run_carry.repository_directory();
-    if (repository2 === void 0) return [];
-    const read = run_carry.read_carry(run_carry.carry_path(repository2));
-    const scope = run_event_scope.scope_of(read);
-    const events = run_event_stream.read_events(run_event_stream.target_of(repository2));
-    return run_event_scope.scoped_events(events, scope);
-  } catch {
-    return void 0;
-  }
-}
-async function current_events() {
-  return await scoped_current_events() ?? [];
-}
-async function invocation_or_all_events() {
-  try {
-    const repository2 = await run_carry.repository_directory();
-    return repository2 === void 0 ? [] : invocation_events(repository2, run_event_stream.target_of(repository2));
-  } catch {
-    return [];
-  }
-}
-async function all_events() {
-  try {
-    const target = await stream_target();
-    return target === void 0 ? [] : run_event_stream.read_events(target);
-  } catch {
-    return [];
-  }
-}
-var run_event_stream_emit = {
-  all_events,
-  current_events,
-  emit,
-  emit_heartbeat,
-  emit_once,
-  emit_once_since,
-  invocation_or_all_events,
-  scoped_current_events,
-  stream_target
-};
-
-// scripts/run/detached-launch.ts
-import { spawn } from "node:child_process";
-import { closeSync, constants, openSync, writeSync } from "node:fs";
-
-// scripts/agent/agent-launch-environment.ts
-import { existsSync as existsSync3, lstatSync, mkdirSync, readlinkSync, symlinkSync, unlinkSync } from "node:fs";
-import path5 from "node:path";
-
-// scripts/gh/gh-cli-token.ts
-import { execaSync as execaSync2 } from "execa";
-var GH_CLI_TIMEOUT_MS = 5e3;
-function get() {
-  try {
-    const { stdout } = execaSync2("gh", ["auth", "token"], { timeout: GH_CLI_TIMEOUT_MS });
-    const token = stdout.trim();
-    return token.length > 0 ? token : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var gh_cli_token = { get };
-
-// scripts/agent/codex-home-source.ts
-import os from "node:os";
-import path4 from "node:path";
-function default_home() {
-  return path4.join(os.homedir(), ".codex");
-}
-var codex_home_source = { default_home };
-
-// scripts/agent/agent-launch-environment.ts
-var OPENAI_PROVIDER = "openai";
-var REVIEWER_HOME = ["node_modules", ".cache", "josh", "openai", "reviewer-home"];
-var HOME_FILES = ["auth.json", "config.toml"];
-var PRIVATE_DIRECTORY_MODE = 448;
-function openai_environment() {
-  const token = gh_cli_token.get();
-  return token === void 0 ? { TMPDIR: PLATFORM_TEMP_ROOT } : { GH_TOKEN: token, TMPDIR: PLATFORM_TEMP_ROOT };
-}
-function remove_old_home_link(source, target) {
-  const current = lstatSync(target, { throwIfNoEntry: false });
-  if (current === void 0) return false;
-  if (!current.isSymbolicLink()) throw new Error(`Reviewer home file is not a link: ${target}`);
-  if (existsSync3(source) && readlinkSync(target) === source) return true;
-  unlinkSync(target);
-  return false;
-}
-function link_home_file(source_home, target_home, name) {
-  const source = path5.join(source_home, name);
-  const target = path5.join(target_home, name);
-  if (!remove_old_home_link(source, target) && existsSync3(source)) symlinkSync(source, target);
-}
-function reviewer_home(cwd, environment3) {
-  const source = environment3["CODEX_HOME"] ?? process.env["CODEX_HOME"] ?? codex_home_source.default_home();
-  const target = path5.resolve(cwd, ...REVIEWER_HOME);
-  mkdirSync(target, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
-  for (const name of HOME_FILES) link_home_file(source, target, name);
-  return target;
-}
-function build2(cwd, profile, environment3 = {}) {
-  if (profile === void 0) return environment3;
-  const marked = {
-    ...agent_headless.environment(),
-    ...agent_session_role.env_for(profile.role),
-    ...environment3
-  };
-  if (profile.provider !== OPENAI_PROVIDER) return marked;
-  const base = { ...openai_environment(), ...marked };
-  return profile.role === agent_role_profile.REVIEWER ? { ...base, CODEX_HOME: reviewer_home(cwd, environment3) } : base;
-}
-var agent_launch_environment = { build: build2 };
-
-// scripts/run/launch-priority.ts
-import { setPriority } from "node:os";
-var LANE_NICENESS = 10;
-function lower(pid, set_priority = setPriority) {
-  if (pid === void 0) return;
-  try {
-    set_priority(pid, LANE_NICENESS);
-  } catch {
-  }
-}
-var launch_priority = {
-  LANE_NICENESS,
-  lower
-};
-
-// scripts/run/detached-launch.ts
-var NO_PID_NOTE = "the process started without a pid";
-var UNSAFE_NOTE = "the wake command or its arguments contain characters that are not safe to execute";
-var { is_safe_prompt, is_safe_value } = agent_role_profile;
-var LAST = -1;
-function is_safe_element(argv, value, index) {
-  const is_prompt = argv.ends_with_prompt === true && index === argv.args.length + LAST;
-  return is_prompt ? is_safe_prompt(value) : is_safe_value(value);
-}
-function is_safe_argv(argv) {
-  return is_safe_value(argv.command) && argv.args.every((value, index) => is_safe_element(argv, value, index));
-}
-function note_of(error) {
-  return error instanceof Error ? error.message : JSON.stringify(error);
-}
-function launched(pid) {
-  return { kind: "launched", pid };
-}
-var LOG_FLAGS = constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW;
-var LOG_MODE = 384;
-function profile_suffix(profile) {
-  return profile === void 0 ? "" : ` \xB7 ${agent_role_profile.describe(profile)}`;
-}
-function log_header(argv, profile) {
-  const stamp = (/* @__PURE__ */ new Date()).toISOString();
-  return `
-=== ${stamp} \xB7 started by process ${String(process.pid)} \xB7 ${argv.command}${profile_suffix(profile)} ===
-`;
-}
-function opened_log(log_path, on_error) {
-  const descriptor = openSync(log_path, LOG_FLAGS, LOG_MODE);
-  if (!stamp_file.is_own_regular_file(log_path)) {
-    closeSync(descriptor);
-    on_error(`${log_path} is not this account's own file, so nothing is kept there`);
-    return void 0;
-  }
-  return descriptor;
-}
-function stamped(descriptor, argv, profile, on_error) {
-  if (descriptor === void 0) return;
-  try {
-    writeSync(descriptor, log_header(argv, profile));
-  } catch (error) {
-    on_error(`the session log could not be written: ${note_of(error)}`);
-  }
-}
-function open_log(log_path, on_error) {
-  if (log_path === void 0) return void 0;
-  try {
-    return opened_log(log_path, on_error);
-  } catch (error) {
-    on_error(`the session log at ${log_path} could not be opened: ${note_of(error)}`);
-    return void 0;
-  }
-}
-function ensure_log(log_path, on_error) {
-  const descriptor = open_log(log_path, on_error);
-  if (descriptor !== void 0) closeSync(descriptor);
-}
-function spawn_options(cwd, log, environment3 = {}, is_detached = true) {
-  return {
-    cwd,
-    detached: is_detached,
-    stdio: log === void 0 ? "ignore" : ["ignore", log, log],
-    env: { ...process.env, ...agent_session_environment.removed_environment(), ...environment3 }
-  };
-}
-function notify_spawn(pid, on_spawn, on_error) {
-  if (pid === void 0) return;
-  try {
-    on_spawn(pid);
-  } catch (error) {
-    on_error(`the child state could not be recorded: ${note_of(error)}`);
-  }
-}
-async function attached_spawn(request, log, on_error, on_spawn) {
-  return await new Promise((resolve2) => {
-    const environment3 = agent_launch_environment.build(request.cwd, request.profile, request.env);
-    const child = spawn(
-      request.argv.command,
-      [...request.argv.args],
-      spawn_options(request.cwd, log, environment3, false)
-    );
-    child.once("error", (error) => {
-      on_error(note_of(error));
-      resolve2({ kind: "failed", note: note_of(error) });
-    });
-    child.once("exit", (exit_code) => {
-      resolve2({ kind: "completed", pid: child.pid ?? 0, exit_code });
-    });
-    launch_priority.lower(child.pid);
-    notify_spawn(child.pid, on_spawn, on_error);
-  });
-}
-function ignore_spawn(_pid) {
-}
-function spawned(request, log, on_error) {
-  const { command, args } = request.argv;
-  const environment3 = agent_launch_environment.build(request.cwd, request.profile, request.env);
-  const child = spawn(command, [...args], spawn_options(request.cwd, log, environment3));
-  child.on("error", (error) => {
-    on_error(note_of(error));
-  });
-  child.unref();
-  launch_priority.lower(child.pid);
-  return child.pid === void 0 ? { kind: "failed", note: NO_PID_NOTE } : launched(child.pid);
-}
-function launch(request, on_error) {
-  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
-  const log = open_log(request.log_path, on_error);
-  try {
-    stamped(log, request.argv, request.profile, on_error);
-    return spawned(request, log, on_error);
-  } catch (error) {
-    return { kind: "failed", note: note_of(error) };
-  } finally {
-    if (log !== void 0) closeSync(log);
-  }
-}
-async function launch_attached(request, on_error, on_spawn = ignore_spawn) {
-  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
-  const log = open_log(request.log_path, on_error);
-  try {
-    stamped(log, request.argv, request.profile, on_error);
-    return await attached_spawn(request, log, on_error, on_spawn);
-  } catch (error) {
-    return { kind: "failed", note: note_of(error) };
-  } finally {
-    if (log !== void 0) closeSync(log);
-  }
-}
-var detached_launch = {
-  UNSAFE_NOTE,
-  ensure_log,
-  is_safe_argv,
-  is_safe_value,
-  launch,
-  launch_attached,
-  log_header,
-  note_of
-};
-
-export {
-  FULL_PAGE_QUERY,
-  git_gh_api_path,
-  parse_json_array_or_undefined,
-  read_json_listing,
-  parse_json_object_or_undefined,
-  gh_failure,
-  has_stderr_field,
-  has_stdout_field,
-  git_gh_exec,
-  git_gh_helpers,
-  MERGED_STATE,
-  to_gh_state,
-  repo_origin,
-  repo_discovery,
-  issue_cite,
-  issue_citation,
-  session_cite,
-  git_common_directory,
-  repository_lock,
-  run_event_stream,
-  run_event_scope,
-  run_event_stream_emit,
-  stamp_record,
-  git_worktree,
-  run_hold,
-  git_gh_pr_rest,
-  forget_pr_numbers,
-  require_pr_number,
-  read_pull,
-  git_gh_pr_read,
-  lane_registry,
-  run_preflight,
-  lane_child_invocation,
-  agent_headless,
-  detached_launch,
-  session_language,
-  process_tools,
-  lane_reap,
-  run_headless
-};