@joshuafolkken/kit 1.1471.0 → 1.1514.0

package/dist/hooks/{chunk-EUMACUK2.js → chunk-WK6SMBIC.js}

@@ -1,9 +1,13 @@
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
+import {
+  agent_role_profile,
+  agent_session_role
+} from "./chunk-UPUZF3AN.js";
 import {
   lane_child_marker
-} from "./chunk-K4EOONYM.js";
+} from "./chunk-LAOV7NLM.js";
 import {
   ENV_FILE_NAME,
   GIT_LOCATION_VARIABLES,
@@ -11,20 +15,24 @@ import {
   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-E7OIKX5Z.js";
+} from "./chunk-APUO6U4J.js";
 import {
+  COMMAND_TIMEOUT_MS,
   INSTALL_TIMEOUT_MS,
   PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
@@ -32,29 +40,238 @@ import {
   stamp_file
 } from "./chunk-DGT54IH5.js";
 
-// scripts/agent/agent-headless.ts
-var KEY = "JOSH_AGENT_HEADLESS";
-var VALUE = "1";
-function environment() {
-  return { [KEY]: VALUE };
+// 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_headless(source = process.env) {
-  return source[KEY] === VALUE;
+function is_github_ssh_host(host) {
+  const normalized = host.toLowerCase();
+  return is_github_hostname(normalized) || SSH_ALIAS_PATTERN.test(normalized);
 }
-var agent_headless = { KEY, environment, is_headless };
+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/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 };
+// 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();
 }
-var session_language = { DEFAULT_SESSION_LANG, ENV_KEY, resolve_session_lang };
+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/lane/lane-reap.ts
-import { execFileSync } from "node:child_process";
+// 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/";
@@ -119,39 +336,394 @@ var issue_cite = {
   unreadable_line
 };
 
-// scripts/run/ship/run-ship-stage.ts
-import { z } 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 = " ";
+// 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 = z.object({
-  done: z.array(z.string()),
-  started: z.array(z.string()).default([])
+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, issue) {
-  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue}${RECORD_SEPARATOR}`, repository2);
+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;
@@ -206,471 +778,104 @@ var DONE_BY = {
 };
 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(issue, stage, phase, started = []) {
-  const words = [issue_cite.plain(issue), 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(text) {
-  return text.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 next_step(issue, stage, resume) {
-  const conflicts = resume.conflicts ?? [];
-  if (conflicts.length > 0) return `${conflict_step(conflicts)} ${AFTER_FIX[stage](resume)}`;
-  return `Read the stopped report with \`${COMMAND.LOG} ${issue}\`, fix the ${stage} failure, then ${AFTER_FIX[stage](resume)}`;
-}
-var run_ship_next = { COMMAND, next_step, quoted, resume_of };
-
-// scripts/lane/lane-child-invocation.ts
-var CHILD_INVOCATION = "fullrun";
-var REVIEW_INVOCATION = "the reviewer of lane";
-var RESUME_GUIDE = ".claude/skills/workflow-commands/pre-gate-cut.md";
-var SHIP_PROCESS = String.raw`(josh(\.[jt]s)? ship|run-ship-cli\.ts)`;
-function child_invocation(issue) {
-  issue_number_shape.require_issue_number(issue);
-  return `${CHILD_INVOCATION} ${issue_cite.plain(issue)}`;
-}
-function process_pattern(issue) {
-  issue_number_shape.require_issue_number(issue);
-  return `(${CHILD_INVOCATION}|${REVIEW_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`;
-}
-function review_invocation(issue) {
-  issue_number_shape.require_issue_number(issue);
-  return `${REVIEW_INVOCATION} ${issue_cite.plain(issue)}`;
-}
-function resume_invocation(issue) {
-  const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue)} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:cut --resume ${issue}\` before anything else and follow the matching verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Only on \`fresh\` proceed as an ordinary`;
-  return `${preamble} ${child_invocation(issue)}`;
-}
-function outage_resume_invocation(issue) {
-  const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue)} after an API disconnection \u2014 your session was restored with its full context, so do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Continue the run from where it stopped: run \`pnpm josh run:step ${issue}\` to find the next action, redoing only the last step if it did not complete.`;
-  return `${preamble} ${child_invocation(issue)}`;
-}
-function ship_stop_invocation(issue, stop) {
-  const opening = `Resuming the lane child for issue ${issue_cite.plain(issue)} after its detached ship supervisor stopped at a failed stage \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md).`;
-  const next = stop === void 0 ? `Run \`pnpm josh run:step ${issue}\` and read the stopped report it names, fix what stopped the ship, then hand the region back per chain-rule.md.` : run_ship_next.next_step(issue, stop.stage, stop);
-  return `${opening} ${next} Do not re-plan or re-implement what is already on the branch. ${child_invocation(issue)}`;
-}
-var lane_child_invocation = {
-  child_invocation,
-  outage_resume_invocation,
-  process_pattern,
-  resume_invocation,
-  review_invocation,
-  ship_stop_invocation
-};
-
-// scripts/lane/process-tools.ts
-import path from "node:path";
-var NOT_FOUND_CODE = "ENOENT";
-var PACKAGE_HINT = "install the package that provides it (procps on Debian/Ubuntu: `apt-get install procps`)";
-function is_not_found(error) {
-  return error instanceof Error && "code" in error && error.code === NOT_FOUND_CODE;
-}
-function missing_notice(command) {
-  return `\`${path.basename(command)}\` is not installed \u2014 kit's lane commands read processes with ps and pgrep; ${PACKAGE_HINT}`;
-}
-function throw_if_missing(command, error) {
-  if (is_not_found(error)) throw new Error(missing_notice(command), { cause: error });
-}
-var process_tools = { missing_notice, throw_if_missing };
-
-// scripts/lane/lane-reap.ts
-var PGREP_COMMAND = "pgrep";
-var MATCH_FULL_COMMAND_LINE = "-f";
-var CHILDREN_OF_FLAG = "-P";
-var PS_COMMAND = "/bin/ps";
-var PARENT_FORMAT = ["-o", "ppid=", "-p"];
-var TERMINATE_SIGNAL = "SIGTERM";
-var LOWEST_CHILD_PID = 2;
-function parse_pids(printed) {
-  return printed.split("\n").map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid >= LOWEST_CHILD_PID);
-}
-function run_probe(command, args) {
-  try {
-    return execFileSync(command, [...args], {
-      encoding: "utf8",
-      timeout: PROBE_TIMEOUT_MS,
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-  } catch (error) {
-    process_tools.throw_if_missing(command, error);
-    return "";
-  }
-}
-function parent_of(pid) {
-  return parse_pids(run_probe(PS_COMMAND, [...PARENT_FORMAT, String(pid)]))[0];
-}
-function 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(issue, own2, probes) {
-  const pattern = lane_child_invocation.process_pattern(issue);
-  return probes.matching(pattern).filter((pid) => !own2.has(pid));
-}
-function reap_child(issue, probes = SYSTEM_PROBES) {
-  const own2 = own_ancestry(probes);
-  const doomed = tree_of(roots_of(issue, own2, probes), probes).filter((pid) => !own2.has(pid));
-  return doomed.filter((pid) => probes.terminate(pid));
-}
-function is_child_running(issue, probes = SYSTEM_PROBES) {
-  return roots_of(issue, own_ancestry(probes), probes).length > 0;
-}
-var lane_reap = {
-  is_child_running,
-  own_ancestry,
-  parse_pids,
-  reap_child
-};
-
-// scripts/lane/lane-registry.ts
-import { existsSync as existsSync2 } from "node:fs";
-import path3 from "node:path";
-
-// scripts/discovery/repo-discovery.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import path2 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 trimmed2 = url.trim();
-  if (trimmed2 === "") return void 0;
-  return parse_url_like(trimmed2) ?? parse_scp_like(trimmed2);
-}
-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_value2) {
-  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_value2)) {
-    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 = path2.join(git_directory, COMMON_DIRECTORY_FILE);
-  if (!existsSync(pointer)) return git_directory;
-  try {
-    return path2.resolve(git_directory, readFileSync(pointer, "utf8").trim());
-  } catch {
-    return git_directory;
-  }
+  return DONE_BY[stage](done, state);
 }
-function follow_git_file(repository_path, git_file) {
-  const pointer = readFileSync(git_file, "utf8").trim();
-  if (!pointer.startsWith(GITDIR_PREFIX)) return void 0;
-  return path2.resolve(repository_path, pointer.slice(GITDIR_PREFIX.length).trim());
+function commit_flags(state) {
+  if (!state.is_committed) return [];
+  return state.is_pushed ? [SKIP_COMMIT_FLAG, SKIP_PUSH_FLAG] : [SKIP_COMMIT_FLAG];
 }
-function resolve_git_directory(repository_path) {
-  const candidate = path2.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 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 read_config(repository_path) {
-  const git_directory = resolve_git_directory(repository_path);
-  if (git_directory === void 0) return void 0;
-  try {
-    return readFileSync(path2.join(git_directory, GIT_CONFIG), "utf8");
-  } catch {
-    return void 0;
-  }
+function started_of(text2) {
+  return text2.split(WORD_SEPARATOR, WORD_COUNT)[STARTED_INDEX]?.split(STARTED_SEPARATOR);
 }
-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);
+var CONFLICT = "conflict";
+function stop_reason(stage, conflicts = []) {
+  return conflicts.length > 0 ? CONFLICT : stage;
 }
-function read_remote_urls(repository_path) {
-  const config = read_config(repository_path);
-  return config === void 0 ? [] : repo_origin.parse_remote_urls_from_config(config);
+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 sibling_directories(parent) {
-  try {
-    return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path2.join(parent, entry.name)).toSorted((left, right) => left.localeCompare(right));
-  } catch {
-    return [];
-  }
+function shell_word(token) {
+  return BARE_WORD.test(token) ? token : quoted(token);
 }
-function scan_siblings(parent) {
-  return sibling_directories(parent).map((repository_path) => ({
-    path: repository_path,
-    origin_url: read_origin_url(repository_path)
-  }));
+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 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 ship_command(command, resume) {
+  const words = [...resume.flags, resume.title].map((token) => shell_word(token));
+  return [command, ...words].join(" ");
 }
-function main_worktree(repository_path) {
-  const git_directory = resolve_git_directory(repository_path);
-  if (git_directory === void 0 || path2.basename(git_directory) !== GIT_DIRECTORY) {
-    return repository_path;
-  }
-  return path2.dirname(git_directory);
+function detach_again(resume) {
+  return `leave the fix uncommitted and run \`${ship_command(COMMAND.DETACH, resume)}\`.`;
 }
-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(path2.dirname(main)),
-    current_owner,
-    environment3[OVERRIDE_ENV_KEY]
-  );
+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 repo_discovery = {
-  OVERRIDE_ENV_KEY,
-  main_worktree,
-  read_origin_url,
-  read_remote_urls,
-  resolve_current_owner,
-  scan_siblings,
-  discover_repositories
+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";
@@ -687,7 +892,7 @@ import { linkSync, renameSync, rmSync } from "node:fs";
 import { setTimeout as sleep } from "node:timers/promises";
 
 // scripts/git/git-common-directory.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync } from "node:child_process";
 var OWN_GIT_DIRECTORY = 0;
 var COMMON_GIT_DIRECTORY = 1;
 var PROBE_TIMEOUT_MS2 = 5e3;
@@ -703,7 +908,7 @@ function cache_key(cwd) {
 }
 function read_directories(cwd) {
   try {
-    const output = execFileSync2(
+    const output = execFileSync(
       git_utilities.get_git_command_for_spawn(),
       [...git_command.GIT_DIRECTORY_ARGUMENTS],
       {
@@ -758,7 +963,7 @@ function parse_owner(raw) {
 function read_owner(target) {
   return parse_owner(stamp_file.read_stamp_text(target));
 }
-function is_owner_gone(owner) {
+function is_owner_gone2(owner) {
   return process_identity.is_same_process(owner.pid, owner.process_start) === false;
 }
 function restore(aside, target) {
@@ -781,7 +986,7 @@ function move_aside(target) {
     return void 0;
   }
 }
-function clear_stale(target, is_gone2 = is_owner_gone) {
+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);
@@ -852,241 +1057,607 @@ async function locked(arguments_, timeout_ms) {
       `git ${arguments_.join(" ")}: timed out waiting for the work-tree lock ${target}`
     );
   }
-  return output;
+  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);
+  }
 }
-async function worktree_list() {
-  return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
+function forget_pr_numbers() {
+  pr_number_by_branch.clear();
+  pending_pr_number_by_branch.clear();
+  pull_by_number.clear();
 }
-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 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 worktree_add_detached(directory, commit) {
-  return await locked([WORKTREE, "add", "--detach", directory, commit], SUITE_TIMEOUT_MS);
+async function resolve_pr_number(branch_name) {
+  const read = await read_pr_number(branch_name);
+  return read.kind === "read" ? read.pr_number : void 0;
 }
-async function worktree_remove(directory) {
-  return await locked([WORKTREE, "remove", "--force", directory], INSTALL_TIMEOUT_MS);
+function to_unreadable_error(branch_name, cause) {
+  return new Error(`${UNREADABLE_PULL_REQUEST_MESSAGE}: ${branch_name}`, { cause });
 }
-async function worktree_prune() {
-  return await locked([WORKTREE, "prune"]);
+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 ls_remote_branch(branch_name) {
-  return await git_spawn.read_remote(ls_remote_branch_arguments(branch_name));
+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 branch_delete(branch_name) {
-  return await git_spawn.read(["branch", "-D", branch_name]);
+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;
+  }
 }
-var git_worktree = {
-  branch_delete,
-  ls_remote_branch,
-  worktree_add,
-  worktree_add_detached,
-  worktree_list,
-  worktree_prune,
-  worktree_remove
-};
-
-// scripts/agent/agent-role-profile.ts
-import { z as z2 } from "zod";
-var FIRST_PRINTABLE_CODE = 32;
-var DELETE_CODE = 127;
-var FIRST_CODE_POINT = 0;
-var EMPTY_LENGTH = 0;
-var MAX_VALUE_LENGTH = 4096;
-var ROLE_SCHEMA = z2.enum(["scheduler", "worker", "reviewer"]);
-var PROVIDER_SCHEMA = z2.enum(["anthropic", "openai"]);
-var EFFORT_SCHEMA = z2.enum(["low", "medium", "high", "xhigh", "max"]);
-var PHASE_SCHEMA = z2.enum(["implementation", "pre-gate"]);
-var PROFILE_SCHEMA = z2.object({
-  provider: PROVIDER_SCHEMA.default("anthropic"),
-  role: ROLE_SCHEMA,
-  model: z2.string(),
-  effort: EFFORT_SCHEMA
-});
-var SCHEDULER = "scheduler";
-var WORKER = "worker";
-var REVIEWER = "reviewer";
-var IMPLEMENTATION_PHASE = "implementation";
-var PRE_GATE_PHASE = "pre-gate";
-var ANTHROPIC_PROVIDER = "anthropic";
-var OPENAI_PROVIDER = "openai";
-var OPENAI_MODEL = "gpt-6.1-sol";
-var ANTHROPIC_MODEL = "claude-opus-5-5";
-var CODEX_SESSION_KEY = "CODEX_THREAD_ID";
-var DEFAULT_PROFILES = {
-  scheduler: {
-    provider: ANTHROPIC_PROVIDER,
-    role: SCHEDULER,
-    model: ANTHROPIC_MODEL,
-    effort: "medium"
-  },
-  worker: { provider: ANTHROPIC_PROVIDER, role: WORKER, model: ANTHROPIC_MODEL, effort: "medium" },
-  reviewer: {
-    provider: ANTHROPIC_PROVIDER,
-    role: REVIEWER,
-    model: ANTHROPIC_MODEL,
-    effort: "high"
+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 };
   }
-};
-var OPENAI_PROFILES = {
-  scheduler: { provider: OPENAI_PROVIDER, role: SCHEDULER, model: OPENAI_MODEL, effort: "medium" },
-  worker: { provider: OPENAI_PROVIDER, role: WORKER, model: OPENAI_MODEL, effort: "medium" },
-  reviewer: { provider: OPENAI_PROVIDER, role: REVIEWER, model: OPENAI_MODEL, effort: "high" }
-};
-var PROVIDER_PROFILES = { anthropic: DEFAULT_PROFILES, openai: OPENAI_PROFILES };
-var SHIP_EFFORT = "low";
-var PHASE_EFFORT = {
-  worker: { [PRE_GATE_PHASE]: SHIP_EFFORT }
-};
-var ENV_KEYS = {
-  scheduler: { model: "JOSH_SCHEDULER_MODEL", effort: "JOSH_SCHEDULER_EFFORT" },
-  worker: { model: "JOSH_WORKER_MODEL", effort: "JOSH_WORKER_EFFORT" },
-  reviewer: { model: "JOSH_REVIEWER_MODEL", effort: "JOSH_REVIEWER_EFFORT" }
-};
-var LEGACY_WORKER_KEYS = { model: "JOSH_LANE_MODEL", effort: "JOSH_LANE_EFFORT" };
-function is_control_character(character) {
-  const code = character.codePointAt(FIRST_CODE_POINT) ?? FIRST_PRINTABLE_CODE;
-  return code < FIRST_PRINTABLE_CODE || code === DELETE_CODE;
-}
-function is_safe_value(value) {
-  if (value.length === EMPTY_LENGTH || value.length > MAX_VALUE_LENGTH) return false;
-  for (const character of value) if (is_control_character(character)) return false;
-  return true;
 }
-function trimmed(value) {
-  const result = value?.trim();
-  return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
+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;
 }
-function override_value(role, field, environment3) {
-  const key = ENV_KEYS[role][field];
-  const value = trimmed(environment3[key]);
-  if (value !== void 0) return { key, value };
-  if (role !== WORKER) return { key, value: void 0 };
-  const legacy = LEGACY_WORKER_KEYS[field];
-  const legacy_value = trimmed(environment3[legacy]);
-  return legacy_value === void 0 ? { key, value: void 0 } : { key: legacy, value: legacy_value };
+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";
 }
-function model_override(role, environment3, provider) {
-  const key = ENV_KEYS[role].model;
-  return provider === OPENAI_PROVIDER ? { key, value: void 0 } : override_value(role, "model", environment3);
+async function pr_get_number(branch_name) {
+  return await resolve_pr_number(branch_name);
 }
-function rejection(key, value, expected) {
-  return { kind: "rejected", note: `${key}=${value} ${expected}, so the agent was not started` };
+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);
 }
-function resolved_effort(override, fallback) {
-  const parsed = EFFORT_SCHEMA.safeParse(override.value ?? fallback);
-  return parsed.success ? { kind: "effort", effort: parsed.data } : rejection(override.key, override.value ?? "", "is not an allowed effort");
+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)
+  };
 }
-function has_session(environment3, keys) {
-  return keys.some((key) => trimmed(environment3[key]) !== void 0);
+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;
+  }
 }
-var CONFLICTING_SESSIONS = {
-  kind: "rejected",
-  note: "both Codex and Claude Code sessions were detected"
-};
-var HANDED_PROVIDER_KEY = "JOSH_AGENT_PROVIDER";
-var DEFAULT_PROVIDER = {
-  kind: "provider",
-  provider: ANTHROPIC_PROVIDER,
-  is_default: true
-};
-var DEFAULT_NOTICE = ` No agent session or ${HANDED_PROVIDER_KEY} was found, so the provider defaulted to ${ANTHROPIC_PROVIDER} (Claude Code).`;
-function handed_provider(environment3) {
-  const value = trimmed(environment3[HANDED_PROVIDER_KEY]);
-  if (value === void 0) return DEFAULT_PROVIDER;
-  const parsed = PROVIDER_SCHEMA.safeParse(value);
-  return parsed.success ? { kind: "provider", provider: parsed.data } : rejection(HANDED_PROVIDER_KEY, value, "is not an allowed provider");
-}
-function detected_provider(environment3) {
-  const has_codex = has_session(environment3, [CODEX_SESSION_KEY]);
-  const has_claude = has_session(environment3, agent_session_environment.PARENT_SESSION_KEYS);
-  if (has_codex === has_claude) return has_codex ? CONFLICTING_SESSIONS : void 0;
-  return { kind: "provider", provider: has_codex ? OPENAI_PROVIDER : ANTHROPIC_PROVIDER };
-}
-function resolve_provider(environment3 = process.env) {
-  return detected_provider(environment3) ?? handed_provider(environment3);
-}
-function default_notice(environment3 = process.env) {
-  const selected = resolve_provider(environment3);
-  return selected.kind === "provider" && selected.is_default === true ? DEFAULT_NOTICE : "";
-}
-function warn_of_default(environment3 = process.env) {
-  const notice = default_notice(environment3).trim();
-  if (notice !== "") console.error(notice);
-}
-function has_completion_callback(environment3 = process.env) {
-  const selected = resolve_provider(environment3);
-  return selected.kind !== "provider" || selected.provider !== OPENAI_PROVIDER;
-}
-function handoff_environment(environment3 = process.env) {
-  const selected = resolve_provider(environment3);
-  return selected.kind === "provider" ? { [HANDED_PROVIDER_KEY]: selected.provider } : {};
-}
-function validate(profile, model_key) {
-  if (!is_safe_value(profile.model)) {
-    return rejection(model_key, profile.model, "is not a safe model");
-  }
-  return { kind: "profile", profile };
-}
-function phase_effort(role, phase, fallback) {
-  const parsed = PHASE_SCHEMA.safeParse(phase);
-  if (!parsed.success) return fallback;
-  return PHASE_EFFORT[role]?.[parsed.data] ?? fallback;
-}
-function overridden_effort(profile, phase, environment3) {
-  const parsed = EFFORT_SCHEMA.safeParse(override_value(profile.role, "effort", environment3).value);
-  return parsed.success ? parsed.data : phase_effort(profile.role, phase, profile.effort);
-}
-function with_phase_effort(profile, phase, environment3 = process.env) {
-  return { ...profile, effort: overridden_effort(profile, phase, environment3) };
-}
-function resolve2(role, environment3 = process.env, phase) {
-  const selected = resolve_provider(environment3);
-  if (selected.kind === "rejected") return selected;
-  const defaults = PROVIDER_PROFILES[selected.provider][role];
-  const model = model_override(role, environment3, selected.provider);
-  const effort = override_value(role, "effort", environment3);
-  const resolved = resolved_effort(effort, phase_effort(role, phase, defaults.effort));
-  if (resolved.kind === "rejected") return resolved;
-  const profile = {
-    provider: selected.provider,
-    role,
-    model: model.value ?? defaults.model,
-    effort: resolved.effort
-  };
-  return validate(profile, model.key);
-}
-function describe(profile) {
-  return `provider=${profile.provider} role=${profile.role} model=${profile.model} effort=${profile.effort}`;
-}
-function parse(value) {
-  const parsed = PROFILE_SCHEMA.safeParse(value);
-  return parsed.success && is_safe_value(parsed.data.model) ? parsed.data : void 0;
-}
-var agent_role_profile = {
-  CODEX_SESSION_KEY,
-  DEFAULT_PROFILES,
-  HANDED_PROVIDER_KEY,
-  IMPLEMENTATION_PHASE,
-  MAX_VALUE_LENGTH,
-  OPENAI_PROFILES,
-  PRE_GATE_PHASE,
-  PROFILE_SCHEMA,
-  REVIEWER,
-  SCHEDULER,
-  WORKER,
-  default_notice,
-  describe,
-  handoff_environment,
-  has_completion_callback,
-  is_safe_value,
-  parse,
-  resolve: resolve2,
-  resolve_provider,
-  warn_of_default,
-  with_phase_effort
+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";
@@ -1100,8 +1671,8 @@ var MIN_QUOTED_LENGTH = 2;
 var FIRST_CHARACTER_END = 1;
 var LAST_CHARACTER_START = -1;
 function strip_export(line) {
-  const trimmed2 = line.trimStart();
-  return trimmed2.startsWith(EXPORT_PREFIX) ? trimmed2.slice(EXPORT_PREFIX.length).trimStart() : trimmed2;
+  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);
@@ -1115,8 +1686,8 @@ function is_output_line(line) {
   return is_key_line(line, LANE_OUTPUT_KEY);
 }
 function split_lines(content) {
-  const trimmed2 = content.trimEnd();
-  return trimmed2.length === 0 ? [] : trimmed2.split("\n");
+  const trimmed = content.trimEnd();
+  return trimmed.length === 0 ? [] : trimmed.split("\n");
 }
 function is_quoted(raw) {
   const first = raw.slice(0, FIRST_CHARACTER_END);
@@ -1223,23 +1794,26 @@ function held_seat(content) {
   return seat_from_content(content) ?? EMPTY_SEAT;
 }
 function read_environment(directory) {
-  return file_reader.read_if_readable(path3.join(directory, ENV_FILE_NAME));
+  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 issue = branch.slice(0, -lane_paths.LANE_BRANCH_SUFFIX.length);
-  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(issue) ? issue : 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(issue, branch, directory, is_stranded) {
+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,
+    issue: issue2,
     branch,
     directory,
     seat: held.seat,
@@ -1247,21 +1821,22 @@ function build_lane(issue, branch, directory, is_stranded) {
     preview_port: held.preview_port,
     output,
     profile,
+    dispatched_ms: is_stranded ? void 0 : dispatched_at(directory),
     is_stranded
   };
 }
-function is_lane_directory(root, issue, directory) {
-  return directory === lane_paths.lane_directory(root, issue);
+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 issue = branch_issue(branch);
-  if (directory === void 0 || branch === void 0 || issue === void 0 || !is_lane_directory(root, issue, directory)) {
+  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(issue, branch, directory, is_gone(directory));
+  return build_lane(issue2, branch, directory, is_gone(directory));
 }
 function is_lane(lane) {
   return lane !== void 0;
@@ -1287,27 +1862,23 @@ async function has_lanes_in_flight() {
   const lanes = await list_lanes();
   return lanes.some((lane) => !lane.is_stranded);
 }
-function live_count(lanes) {
-  return lanes.filter((lane) => !lane.is_stranded).length;
-}
 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, issue) {
-  return lanes.find((lane) => lane.issue === issue);
+function find_lane(lanes, issue2) {
+  return lanes.find((lane) => lane.issue === issue2);
 }
-async function find_open_lane(issue) {
-  return find_lane(await list_lanes(), issue);
+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,
-  live_count,
   main_repository_root,
   parse_block,
   read_environment,
@@ -1316,6 +1887,522 @@ var lane_registry = {
   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";
@@ -1375,7 +2462,7 @@ var run_headless = {
 };
 
 // scripts/run/event/run-event-stream.ts
-import { z as z3 } from "zod";
+import { z as z7 } from "zod";
 var EVENT_PREFIX = "josh-run-events-";
 var EVENT_SUFFIX = ".jsonl";
 var EVENT_CAP = 500;
@@ -1402,6 +2489,10 @@ var EVENT_KIND = {
   // (`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
@@ -1496,11 +2587,11 @@ var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
   EVENT_KIND.SETUP,
   EVENT_KIND.PR_CHECKS
 ]);
-var event_schema = z3.object({
-  pos: z3.number(),
-  at: z3.string(),
-  kind: z3.string(),
-  text: z3.string()
+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);
@@ -1570,11 +2661,11 @@ function append_held(target, event) {
   stamp_file.replace_text_stamp(target, serialize(events));
   return position;
 }
-function append(target, kind, text, at) {
+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 }),
+    () => append_held(target, { at, kind, text: text2 }),
     lock,
     LOCK_WAIT_MS
   );
@@ -1654,58 +2745,69 @@ 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, issue) {
-  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain(issue)} `);
+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, issue) {
-  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue);
+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, issue) {
-  return issue_named(event) === issue;
+function names_issue(event, issue2) {
+  return issue_named(event) === issue2;
 }
-function is_lane_position(event, issue) {
-  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue);
+function is_lane_position(event, issue2) {
+  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue2);
 }
-function since_own_launch(events, issue) {
+function since_own_launch(events, issue2) {
   const launch2 = events.findLastIndex(
-    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue)
+    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue2)
   );
   return events.slice(launch2 + 1);
 }
-function is_foreign_event(event, issue, is_lane_child) {
-  if (is_lane_child) return !is_lane_position(event, issue);
-  return is_foreign_ship_event(event, issue);
+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, issue, is_lane_child) {
-  const attempt = is_lane_child ? since_own_launch(events, issue) : events;
-  const own2 = attempt.filter((event) => !is_foreign_event(event, issue, is_lane_child));
+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, issue));
+  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.SPLIT,
+  KIND.WITHDRAW
 ]);
-function is_merge_owed(events, scope, issue) {
+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, issue)
+    (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,
@@ -1723,19 +2825,19 @@ 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, text) {
+async function emit(kind, text2) {
   try {
     const target = await stream_target();
     if (target === void 0) return;
-    run_event_stream.append(target, kind, text, now_iso());
+    run_event_stream.append(target, kind, text2, now_iso());
   } catch {
   }
 }
-async function emit_once(kind, text) {
+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, text, now_iso()).appended;
+    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;
@@ -1746,7 +2848,7 @@ function invocation_events(repository2, 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, text, reset_kind) {
+async function emit_once_since(kind, text2, reset_kind) {
   try {
     const repository2 = await run_carry.repository_directory();
     if (repository2 === void 0) return false;
@@ -1754,7 +2856,7 @@ async function emit_once_since(kind, text, reset_kind) {
     if (run_event_stream.has_since(invocation_events(repository2, target), kind, reset_kind)) {
       return false;
     }
-    return run_event_stream.append(target, kind, text, now_iso()).appended;
+    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;
@@ -1763,18 +2865,21 @@ async function emit_once_since(kind, text, reset_kind) {
 async function emit_heartbeat(line) {
   await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
 }
-async function current_events() {
+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) ?? [];
+    return run_event_scope.scoped_events(events, scope);
   } catch {
-    return [];
+    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();
@@ -1799,6 +2904,7 @@ var run_event_stream_emit = {
   emit_once,
   emit_once_since,
   invocation_or_all_events,
+  scoped_current_events,
   stream_target
 };
 
@@ -1811,11 +2917,11 @@ import { existsSync as existsSync3, lstatSync, mkdirSync, readlinkSync, symlinkS
 import path5 from "node:path";
 
 // scripts/gh/gh-cli-token.ts
-import { execaSync } from "execa";
+import { execaSync as execaSync2 } from "execa";
 var GH_CLI_TIMEOUT_MS = 5e3;
 function get() {
   try {
-    const { stdout } = execaSync("gh", ["auth", "token"], { timeout: GH_CLI_TIMEOUT_MS });
+    const { stdout } = execaSync2("gh", ["auth", "token"], { timeout: GH_CLI_TIMEOUT_MS });
     const token = stdout.trim();
     return token.length > 0 ? token : void 0;
   } catch {
@@ -1824,16 +2930,6 @@ function get() {
 }
 var gh_cli_token = { get };
 
-// scripts/agent/agent-session-role.ts
-var KEY2 = "JOSH_AGENT_ROLE";
-function environment_for(role) {
-  return { [KEY2]: role };
-}
-function is_reviewer(source = process.env) {
-  return source[KEY2] === agent_role_profile.REVIEWER;
-}
-var agent_session_role = { KEY: KEY2, env_for: environment_for, is_reviewer };
-
 // scripts/agent/codex-home-source.ts
 import os from "node:os";
 import path4 from "node:path";
@@ -1843,7 +2939,7 @@ function default_home() {
 var codex_home_source = { default_home };
 
 // scripts/agent/agent-launch-environment.ts
-var OPENAI_PROVIDER2 = "openai";
+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;
@@ -1871,25 +2967,45 @@ function reviewer_home(cwd, environment3) {
   for (const name of HOME_FILES) link_home_file(source, target, name);
   return target;
 }
-function build(cwd, profile, environment3 = {}) {
+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_PROVIDER2) return marked;
+  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 };
+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_value: is_safe_value2 } = agent_role_profile;
+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_value2(argv.command) && argv.args.every((value) => is_safe_value2(value));
+  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);
@@ -1955,7 +3071,7 @@ function notify_spawn(pid, on_spawn, on_error) {
   }
 }
 async function attached_spawn(request, log, on_error, on_spawn) {
-  return await new Promise((resolve3) => {
+  return await new Promise((resolve2) => {
     const environment3 = agent_launch_environment.build(request.cwd, request.profile, request.env);
     const child = spawn(
       request.argv.command,
@@ -1964,11 +3080,12 @@ async function attached_spawn(request, log, on_error, on_spawn) {
     );
     child.once("error", (error) => {
       on_error(note_of(error));
-      resolve3({ kind: "failed", note: note_of(error) });
+      resolve2({ kind: "failed", note: note_of(error) });
     });
     child.once("exit", (exit_code) => {
-      resolve3({ kind: "completed", pid: child.pid ?? 0, exit_code });
+      resolve2({ kind: "completed", pid: child.pid ?? 0, exit_code });
     });
+    launch_priority.lower(child.pid);
     notify_spawn(child.pid, on_spawn, on_error);
   });
 }
@@ -1982,6 +3099,7 @@ function spawned(request, log, on_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) {
@@ -2012,7 +3130,7 @@ var detached_launch = {
   UNSAFE_NOTE,
   ensure_log,
   is_safe_argv,
-  is_safe_value: is_safe_value2,
+  is_safe_value,
   launch,
   launch_attached,
   log_header,
@@ -2020,19 +3138,43 @@ var detached_launch = {
 };
 
 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,
-  agent_role_profile,
-  agent_session_role,
+  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,
-  lane_registry,
+  process_tools,
+  lane_reap,
   run_headless
 };