@joshuafolkken/kit 1.929.0 → 1.953.0

package/dist/hooks/{chunk-GQ3EVWHY.js → chunk-452OKRQX.js}

@@ -1,17 +1,18 @@
 import {
   lane_child_marker,
   run_issue_number
-} from "./chunk-SXPTRFPG.js";
+} from "./chunk-O3PEDF3M.js";
 import {
   PLATFORM_TEMP_ROOT,
   cost_blocks,
   cost_usage,
+  json_value,
   lane_paths,
   stamp_file,
   time_density_hook,
   time_shell,
   time_transcript_line
-} from "./chunk-2PGRQ62K.js";
+} from "./chunk-EYFJ74MJ.js";
 import {
   ENV_FILE_NAME,
   LANE_SEAT_KEY,
@@ -111,6 +112,7 @@ var filing_cap = {
 import { platform } from "node:os";
 var GIT_COMMAND_UNIX = "/usr/bin/git";
 var PORCELAIN_FLAG = "--porcelain";
+var UNTRACKED_FILES_FLAG = "--untracked-files=all";
 function get_git_command() {
   if (platform() === "win32") {
     return String.raw`"C:\Program Files\Git\cmd\git.exe"`;
@@ -242,7 +244,7 @@ async function branch() {
   return await git_spawn.read(["rev-parse", "--abbrev-ref", "HEAD"]);
 }
 async function status() {
-  return await git_spawn.read(["status", PORCELAIN_FLAG, "--untracked-files=normal"]);
+  return await git_spawn.read(["status", PORCELAIN_FLAG, UNTRACKED_FILES_FLAG]);
 }
 async function repository_root() {
   return await git_spawn.read(["rev-parse", "--show-toplevel"]);
@@ -1516,6 +1518,112 @@ var run_cut = {
   worktree_git_directory_sync
 };
 
+// scripts/rules/shell-segments.ts
+var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
+function segments_of(command) {
+  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
+}
+function is_josh_command(segment, names) {
+  const named = time_shell.josh_command_of(segment);
+  if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
+  return names.has(named.slice(time_shell.JOSH_PREFIX.length));
+}
+var shell_segments = {
+  SEGMENT_SEPARATOR,
+  is_josh_command,
+  segments_of
+};
+
+// scripts/rules/run-tail.ts
+var SEGMENT_PREFIX = String.raw`(?:\(\s*)?(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:npx\s+|pnpm\s+(?:exec\s+|run\s+)?)?`;
+var WORD_END = String.raw`(?=\s|$|\))`;
+var PUSH_STEP_SEGMENT = new RegExp(String.raw`^${SEGMENT_PREFIX}josh\s+(?:git|g)${WORD_END}`, "u");
+var CONFIRMED_FLAG = new RegExp(String.raw`(?:^|\s)(?:-y|--yes)${WORD_END}`, "u");
+var SKIPS_THE_PUSH = new RegExp(String.raw`(?:^|\s)--skip-push${WORD_END}`, "u");
+var BACKGROUND_KEY = "run_in_background";
+var QUOTED_SPAN = /"[^"]*"|'[^']*'/gu;
+function flags_of(segment) {
+  return segment.replaceAll(QUOTED_SPAN, " ");
+}
+function is_push_step_segment(segment) {
+  if (!PUSH_STEP_SEGMENT.test(segment)) return false;
+  const flags = flags_of(segment);
+  if (SKIPS_THE_PUSH.test(flags)) return false;
+  return CONFIRMED_FLAG.test(flags);
+}
+function is_push_step(command) {
+  return shell_segments.segments_of(command).some((segment) => is_push_step_segment(segment));
+}
+function is_backgrounded(input) {
+  if (!json_value.is_record(input)) return false;
+  return input[BACKGROUND_KEY] === true;
+}
+function is_push_step_call(call) {
+  if (call.name !== cost_blocks.BASH_TOOL) return false;
+  return is_push_step(time_shell.bash_command(call.input));
+}
+function is_backgrounded_push_step(call) {
+  if (!is_backgrounded(call.input)) return false;
+  return is_push_step_call(call);
+}
+function is_foreground_push_step(call) {
+  if (is_backgrounded(call.input)) return false;
+  return is_push_step_call(call);
+}
+function decide3() {
+  return true;
+}
+var RUN_TAIL_REASON = '\u26D4 run tail: this issues the commit-push-PR step in the foreground, where the harness decides when to stop waiting. Reissue it with `run_in_background` set. In `fullrun #1501` this call was given a 900-second timeout, the harness detached it at its own 600-second cap, and nothing read the output for a further 6m28s \u2014 45m03s of wall clock on about 17 minutes of work (joshuafolkken/kit#1510). **Never give a foreground call a timeout above the harness cap**: the cap decides, not the number. A backgrounded call re-invokes you when it exits, so the completion notification is what resumes the run. **When it arrives, the turn that reads it goes straight through any branch-2 filing and `pnpm josh epic:bundle` to `pnpm josh followup` \u2014 the turn never ends at the push.** CI went green 6m06s before the merge started in that run, and it started only because the person asked; joshuafolkken/kit#1333 had already settled that the merge is issued in the turn the review closes. While the push runs, do the work that writes nothing \u2014 drafting the completion body to a file, deciding the branch-2 disposition. `pnpm josh followup` itself stays in the **foreground** \u2014 nearly every step after it reads its result. But a tail does follow the merge, measured at 3.0 min and 5.9% of a run (joshuafolkken/kit#1462), so empty it beforehand: the steps that read the merge result stay after `followup`, and the rest are composed in the turn that issues it, bar the one exception background-commands.md names. The procedure is `.claude/skills/workflow-commands/background-commands.md`, "A command that can take minutes is issued in the background". **This rule fires on every foreground push, not once per run**, so reissuing the same call in the foreground will be refused again.';
+var run_tail = {
+  RUN_TAIL_REASON,
+  decide: decide3,
+  is_backgrounded_push_step,
+  is_foreground_push_step,
+  is_push_step,
+  is_push_step_call
+};
+
+// scripts/rules/lane-background.ts
+var LONG_RUNNING_COMMANDS = new Set(
+  ["gate", "git", "followup"].map((name) => `${time_shell.JOSH_PREFIX}${name}`)
+);
+var BACKGROUND_KEY2 = "run_in_background";
+function is_backgrounded2(input) {
+  return json_value.is_record(input) && input[BACKGROUND_KEY2] === true;
+}
+function runs_long_command(command) {
+  return time_shell.josh_commands_of(command).some((name) => LONG_RUNNING_COMMANDS.has(name));
+}
+function is_candidate(call) {
+  if (run_tail.is_push_step_call(call)) return true;
+  if (call.name !== cost_blocks.BASH_TOOL || !is_backgrounded2(call.input)) return false;
+  return runs_long_command(time_shell.bash_command(call.input));
+}
+function is_background_long_run(call, is_lane_child = () => lane_child_marker.is_child_of(process.cwd())) {
+  return is_candidate(call) && is_lane_child();
+}
+function pending_background_ids(tail) {
+  const lines = tail.split("\n").map((line) => time_transcript_line.parse_line(line));
+  const finished = new Set(lines.map((line) => line?.finished_background ?? ""));
+  const launched = lines.flatMap((line) => line?.blocks.map((block) => block.background_id) ?? []);
+  return launched.filter((id) => id !== "" && !finished.has(id));
+}
+var LANE_BACKGROUND_REASON = '\u26D4 lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless `claude -p` process whose background Bash tasks are killed when the turn ends \u2014 so a backgrounded `josh gate` / `josh git` / `josh followup` never re-invokes you; it dies at `exit code 143` (joshuafolkken/kit#2704, measured on the #2606 child: implementation, review and live verification done, the run parked instead of merged). Hand the gate-to-merge region to the detached supervisor instead: `pnpm josh ship --detach --review "<title> #<N>"` (add `--cite <N>`), then end the turn on `launched` / `busy` \u2014 `.claude/skills/workflow-commands/chain-rule.md` step 0 is the single source. A single check you must read before continuing runs in the foreground within the tool timeout; the commit-push step does not \u2014 in a child it too belongs to the detached ship, in either spelling. This rule fires on every occurrence, not once per run.';
+var LANE_BACKGROUND_STOP_REASON = "\u26D4 lane background stop: this is a dispatched lane child (`JOSH_LANE_CHILD`) and a background task it launched has not finished \u2014 ending this headless turn kills it, and nothing re-invokes you afterwards (joshuafolkken/kit#2704). Do not send a notification and do not stop: wait for the task in the foreground and act on its result, or re-issue the work through `pnpm josh ship --detach`, whose supervisor outlives the turn (`.claude/skills/workflow-commands/chain-rule.md` step 0). Do not repeat your previous reply.";
+var ROW2 = {
+  id: "lane-background",
+  is_trigger: (call) => is_background_long_run(call),
+  reason: LANE_BACKGROUND_REASON,
+  decide: () => true
+};
+var lane_background = {
+  LANE_BACKGROUND_REASON,
+  LANE_BACKGROUND_STOP_REASON,
+  ROW: ROW2,
+  is_background_long_run,
+  pending_background_ids
+};
+
 // scripts/git/issue-labels.ts
 var BUG_LABEL = "bug";
 var ENHANCEMENT_LABEL = "enhancement";
@@ -1535,22 +1643,6 @@ function has_label_name(labels, wanted) {
   return label_name_of(labels, wanted) !== void 0;
 }
 
-// scripts/rules/shell-segments.ts
-var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
-function segments_of(command) {
-  return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
-}
-function is_josh_command(segment, names) {
-  const named = time_shell.josh_command_of(segment);
-  if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
-  return names.has(named.slice(time_shell.JOSH_PREFIX.length));
-}
-var shell_segments = {
-  SEGMENT_SEPARATOR,
-  is_josh_command,
-  segments_of
-};
-
 // scripts/rules/lane-park.ts
 var NOTIFY_COMMANDS = /* @__PURE__ */ new Set(["notify"]);
 var CONFIRMATION_TASK_TYPE = /(?:^|\s)--task-type[=\s]+["']?confirmation\b/u;
@@ -1814,8 +1906,8 @@ function current_owner(repository_path = process.cwd()) {
 var repo_party = { FIRST_PARTY, THIRD_PARTY, UNKNOWN, classify: classify3, current_owner, target_owner };
 
 // scripts/lane/lane-registry.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
-import path2 from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
+import path3 from "node:path";
 
 // scripts/git/git-ls-remote.ts
 var LS_REMOTE_COMMAND = "ls-remote";
@@ -1826,23 +1918,323 @@ function ls_remote_branch_arguments(branch_name) {
   return [LS_REMOTE_COMMAND, HEADS_FLAG, ORIGIN_REMOTE, `${HEADS_REF_PREFIX}${branch_name}`];
 }
 
+// scripts/git/repository-lock.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { linkSync, renameSync, rmSync as rmSync2 } from "node:fs";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// scripts/josh/process-identity.ts
+import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFileSync as readFileSync3, rmSync } from "node:fs";
+import { createServer } from "node:net";
+import path2 from "node:path";
+var PS_COMMAND = "/bin/ps";
+var FORMAT_FLAG = "-o";
+var START_TIME_FORMAT = "lstart=";
+var PID_FLAG = "-p";
+var PROBE_ENVIRONMENT = { TZ: "UTC", LC_ALL: "C" };
+var PROBE_TIMEOUT_MS = 2e3;
+var LIVENESS_SIGNAL = 0;
+var LOWEST_REAL_PID = 1;
+var PROC_START_FIELD_INDEX = 19;
+var BEACON_SCHEME = "socket:";
+var BEACON_SUFFIX = ".sock";
+var BEACON_PREFIX = `josh-process-identity-${String(process.getuid?.() ?? "")}-`;
+var BEACON_ID_LENGTH = 36;
+var BEACON_ID_PATTERN = /^[\da-f-]+$/u;
+var WINDOWS_PLATFORM = "win32";
+var SOCKET_PROBE_SOURCE = "const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(0));socket.once('error',()=>process.exit(1));socket.setTimeout(1000,()=>process.exit(1));";
+var beacons = /* @__PURE__ */ new Map();
+var exit_cleanup = { is_registered: false };
+function is_live_pid(pid) {
+  if (pid < LOWEST_REAL_PID) return false;
+  try {
+    process.kill(pid, LIVENESS_SIGNAL);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function read_proc_start(pid) {
+  try {
+    const stat = readFileSync3(`/proc/${String(pid)}/stat`, "utf8");
+    const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u);
+    const start = fields[PROC_START_FIELD_INDEX];
+    return start === void 0 ? void 0 : `proc:${start}`;
+  } catch {
+    return void 0;
+  }
+}
+function read_ps_start(pid) {
+  try {
+    const printed = execFileSync2(
+      PS_COMMAND,
+      [FORMAT_FLAG, START_TIME_FORMAT, PID_FLAG, String(pid)],
+      {
+        encoding: "utf8",
+        timeout: PROBE_TIMEOUT_MS,
+        stdio: ["ignore", "pipe", "ignore"],
+        env: PROBE_ENVIRONMENT
+      }
+    ).trim();
+    return printed.length > 0 ? printed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var START_PROBES = { read_proc_start, read_ps_start };
+function safe_probe(probe, pid) {
+  try {
+    return probe(pid);
+  } catch {
+    return void 0;
+  }
+}
+function read_start(pid, probes = START_PROBES) {
+  return safe_probe(probes.read_proc_start, pid) ?? safe_probe(probes.read_ps_start, pid);
+}
+function close_beacon(token) {
+  const server = beacons.get(token);
+  if (server === void 0) return;
+  beacons.delete(token);
+  server.close();
+  rmSync(token.slice(BEACON_SCHEME.length), { force: true });
+}
+function close_beacons() {
+  for (const token of beacons.keys()) close_beacon(token);
+}
+function ensure_exit_cleanup() {
+  if (exit_cleanup.is_registered) return;
+  exit_cleanup.is_registered = true;
+  process.once("exit", close_beacons);
+}
+function ignore_beacon_error() {
+}
+function bind_beacon(target) {
+  return createServer().on("error", ignore_beacon_error).listen(target);
+}
+function try_bind_beacon(bind, target) {
+  try {
+    const server = bind(target);
+    return server.listening ? server : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function open_beacon(bind = bind_beacon) {
+  const target = path2.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
+  const token = `${BEACON_SCHEME}${target}`;
+  const server = try_bind_beacon(bind, target);
+  if (server === void 0) return void 0;
+  server.unref();
+  beacons.set(token, server);
+  ensure_exit_cleanup();
+  return token;
+}
+function resolve_own_start(probes = START_PROBES, platform2 = process.platform) {
+  const start = read_start(process.pid, probes);
+  if (start !== void 0 || platform2 === WINDOWS_PLATFORM) return start;
+  return open_beacon();
+}
+function is_valid_beacon_name(name) {
+  if (!name.startsWith(BEACON_PREFIX) || !name.endsWith(BEACON_SUFFIX)) return false;
+  const id = name.slice(BEACON_PREFIX.length, -BEACON_SUFFIX.length);
+  return id.length === BEACON_ID_LENGTH && BEACON_ID_PATTERN.test(id);
+}
+function beacon_target(token) {
+  if (!token.startsWith(BEACON_SCHEME)) return void 0;
+  const target = token.slice(BEACON_SCHEME.length);
+  if (path2.dirname(target) !== PLATFORM_TEMP_ROOT) return void 0;
+  return is_valid_beacon_name(path2.basename(target)) ? target : void 0;
+}
+function is_live_beacon(target) {
+  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
+    stdio: "ignore",
+    timeout: PROBE_TIMEOUT_MS
+  }).status === 0;
+}
+function has_matching_start(pid, recorded_start, read2) {
+  const observed = read2(pid);
+  return observed === void 0 ? void 0 : observed === recorded_start;
+}
+function matches_recorded_start(pid, recorded_start, read2) {
+  const target = beacon_target(recorded_start);
+  return target === void 0 ? has_matching_start(pid, recorded_start, read2) : is_live_beacon(target);
+}
+var own_probe = /* @__PURE__ */ new Map();
+function own_start() {
+  if (!own_probe.has(process.pid)) own_probe.set(process.pid, resolve_own_start());
+  return own_probe.get(process.pid);
+}
+function own_fields() {
+  const start = own_start();
+  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
+}
+function is_same_process(pid, recorded_start, read2 = read_start) {
+  if (pid === void 0 || !is_live_pid(pid)) return false;
+  if (recorded_start === void 0) return void 0;
+  return matches_recorded_start(pid, recorded_start, read2);
+}
+function is_own_process(pid, recorded_start) {
+  return pid === process.pid && recorded_start === own_start();
+}
+var process_identity = {
+  close_beacon,
+  is_live_pid,
+  is_own_process,
+  is_same_process,
+  open_beacon,
+  own_fields,
+  own_start,
+  read_start,
+  resolve_own_start
+};
+
+// scripts/git/git-common-directory.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+var OWN_GIT_DIRECTORY = 0;
+var COMMON_GIT_DIRECTORY = 1;
+var PROBE_TIMEOUT_MS2 = 2e3;
+function read_directories(cwd) {
+  const git = git_utilities.get_git_command_for_spawn();
+  const output = execFileSync3(git, [...git_command.GIT_DIRECTORY_ARGUMENTS], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: PROBE_TIMEOUT_MS2
+  });
+  return output.trim().split("\n");
+}
+function select_linked(directories) {
+  const own = directories[OWN_GIT_DIRECTORY];
+  const common = directories[COMMON_GIT_DIRECTORY];
+  return own !== void 0 && common !== void 0 && own !== common ? common : void 0;
+}
+function resolve2(cwd) {
+  try {
+    return select_linked(read_directories(cwd));
+  } catch {
+    return void 0;
+  }
+}
+function repository(cwd) {
+  try {
+    return read_directories(cwd)[COMMON_GIT_DIRECTORY];
+  } catch {
+    return void 0;
+  }
+}
+var git_common_directory = { repository, resolve: resolve2, select_linked };
+
+// scripts/git/repository-lock.ts
+var POLL_INTERVAL_MS = 200;
+function lock_path(prefix, cwd = process.cwd()) {
+  return stamp_file.stamp_path(prefix, git_common_directory.repository(cwd) ?? cwd);
+}
+function parse_owner(raw) {
+  if (raw === void 0) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function read_owner(target) {
+  return parse_owner(stamp_file.read_stamp_text(target));
+}
+function is_owner_gone(owner) {
+  return process_identity.is_same_process(owner.pid, owner.process_start) === false;
+}
+function restore(aside, target) {
+  try {
+    linkSync(aside, target);
+  } catch {
+  }
+}
+function stale_record(target, is_gone2) {
+  const raw = stamp_file.read_stamp_text(target);
+  const owner = parse_owner(raw);
+  return owner !== void 0 && is_gone2(owner) ? raw : void 0;
+}
+function move_aside(target) {
+  const aside = `${target}.${String(process.pid)}.${randomUUID2()}`;
+  try {
+    renameSync(target, aside);
+    return aside;
+  } catch {
+    return void 0;
+  }
+}
+function clear_stale(target, is_gone2 = is_owner_gone) {
+  const raw = stale_record(target, is_gone2);
+  if (raw === void 0) return;
+  const aside = move_aside(target);
+  if (aside === void 0) return;
+  if (stamp_file.read_stamp_text(aside) !== raw) restore(aside, target);
+  rmSync2(aside, { force: true });
+}
+function claim(target) {
+  clear_stale(target);
+  return stamp_file.create_stamp(target, process_identity.own_fields());
+}
+function release(target) {
+  const owner = read_owner(target);
+  if (owner !== void 0 && process_identity.is_own_process(owner.pid, owner.process_start)) {
+    stamp_file.remove_stamp(target);
+  }
+}
+async function acquire(target, max_wait_ms) {
+  const deadline = Date.now() + max_wait_ms;
+  while (!claim(target)) {
+    if (Date.now() >= deadline) return false;
+    await sleep(POLL_INTERVAL_MS);
+  }
+  return true;
+}
+async function with_lock(work, target, max_wait_ms) {
+  if (!await acquire(target, max_wait_ms)) return void 0;
+  try {
+    return await work();
+  } finally {
+    release(target);
+  }
+}
+var repository_lock = { clear_stale, lock_path, with_lock };
+
 // scripts/git/git-worktree.ts
 var WORKTREE = "worktree";
+var WORKTREE_LOCK_PREFIX = "josh-worktree-lock-";
+var WORKTREE_LOCK_MAX_WAIT_MS = 12e4;
+async function locked(arguments_) {
+  const target = repository_lock.lock_path(WORKTREE_LOCK_PREFIX);
+  const output = await repository_lock.with_lock(
+    async () => await git_spawn.read(arguments_),
+    target,
+    WORKTREE_LOCK_MAX_WAIT_MS
+  );
+  if (output === void 0) {
+    throw new Error(
+      `git ${arguments_.join(" ")}: timed out waiting for the work-tree lock ${target}`
+    );
+  }
+  return output;
+}
 async function worktree_list() {
   return await git_spawn.read([WORKTREE, "list", PORCELAIN_FLAG]);
 }
 async function worktree_add(directory, branch_name, start_point) {
   const flags = start_point === void 0 ? ["add"] : ["add", "--no-track", "-b", branch_name];
-  return await git_spawn.read([WORKTREE, ...flags, directory, start_point ?? branch_name]);
+  return await locked([WORKTREE, ...flags, directory, start_point ?? branch_name]);
 }
 async function worktree_add_detached(directory, commit2) {
-  return await git_spawn.read([WORKTREE, "add", "--detach", directory, commit2]);
+  return await locked([WORKTREE, "add", "--detach", directory, commit2]);
 }
 async function worktree_remove(directory) {
-  return await git_spawn.read([WORKTREE, "remove", "--force", directory]);
+  return await locked([WORKTREE, "remove", "--force", directory]);
 }
 async function worktree_prune() {
-  return await git_spawn.read([WORKTREE, "prune"]);
+  return await locked([WORKTREE, "prune"]);
 }
 async function ls_remote_branch(branch_name) {
   return await git_spawn.read(ls_remote_branch_arguments(branch_name));
@@ -2005,7 +2397,7 @@ function held_seat(content) {
 }
 function read_environment(directory) {
   try {
-    return readFileSync3(path2.join(directory, ENV_FILE_NAME), "utf8");
+    return readFileSync4(path3.join(directory, ENV_FILE_NAME), "utf8");
   } catch {
     return void 0;
   }
@@ -2371,174 +2763,6 @@ var run_invocation = {
   rebuild
 };
 
-// scripts/josh/process-identity.ts
-import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { readFileSync as readFileSync4, rmSync } from "node:fs";
-import { createServer } from "node:net";
-import path3 from "node:path";
-var PS_COMMAND = "/bin/ps";
-var FORMAT_FLAG = "-o";
-var START_TIME_FORMAT = "lstart=";
-var PID_FLAG = "-p";
-var PROBE_ENVIRONMENT = { TZ: "UTC", LC_ALL: "C" };
-var PROBE_TIMEOUT_MS = 2e3;
-var LIVENESS_SIGNAL = 0;
-var LOWEST_REAL_PID = 1;
-var PROC_START_FIELD_INDEX = 19;
-var BEACON_SCHEME = "socket:";
-var BEACON_SUFFIX = ".sock";
-var BEACON_PREFIX = `josh-process-identity-${String(process.getuid?.() ?? "")}-`;
-var BEACON_ID_LENGTH = 36;
-var BEACON_ID_PATTERN = /^[\da-f-]+$/u;
-var WINDOWS_PLATFORM = "win32";
-var SOCKET_PROBE_SOURCE = "const net=require('node:net');const socket=net.createConnection(process.argv[1]);socket.once('connect',()=>process.exit(0));socket.once('error',()=>process.exit(1));socket.setTimeout(1000,()=>process.exit(1));";
-var beacons = /* @__PURE__ */ new Map();
-var exit_cleanup = { is_registered: false };
-function is_live_pid(pid) {
-  if (pid < LOWEST_REAL_PID) return false;
-  try {
-    process.kill(pid, LIVENESS_SIGNAL);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function read_proc_start(pid) {
-  try {
-    const stat = readFileSync4(`/proc/${String(pid)}/stat`, "utf8");
-    const fields = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/u);
-    const start = fields[PROC_START_FIELD_INDEX];
-    return start === void 0 ? void 0 : `proc:${start}`;
-  } catch {
-    return void 0;
-  }
-}
-function read_ps_start(pid) {
-  try {
-    const printed = execFileSync2(
-      PS_COMMAND,
-      [FORMAT_FLAG, START_TIME_FORMAT, PID_FLAG, String(pid)],
-      {
-        encoding: "utf8",
-        timeout: PROBE_TIMEOUT_MS,
-        stdio: ["ignore", "pipe", "ignore"],
-        env: PROBE_ENVIRONMENT
-      }
-    ).trim();
-    return printed.length > 0 ? printed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var START_PROBES = { read_proc_start, read_ps_start };
-function safe_probe(probe, pid) {
-  try {
-    return probe(pid);
-  } catch {
-    return void 0;
-  }
-}
-function read_start(pid, probes = START_PROBES) {
-  return safe_probe(probes.read_proc_start, pid) ?? safe_probe(probes.read_ps_start, pid);
-}
-function close_beacon(token) {
-  const server = beacons.get(token);
-  if (server === void 0) return;
-  beacons.delete(token);
-  server.close();
-  rmSync(token.slice(BEACON_SCHEME.length), { force: true });
-}
-function close_beacons() {
-  for (const token of beacons.keys()) close_beacon(token);
-}
-function ensure_exit_cleanup() {
-  if (exit_cleanup.is_registered) return;
-  exit_cleanup.is_registered = true;
-  process.once("exit", close_beacons);
-}
-function ignore_beacon_error() {
-}
-function bind_beacon(target) {
-  return createServer().on("error", ignore_beacon_error).listen(target);
-}
-function try_bind_beacon(bind, target) {
-  try {
-    const server = bind(target);
-    return server.listening ? server : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function open_beacon(bind = bind_beacon) {
-  const target = path3.join(PLATFORM_TEMP_ROOT, `${BEACON_PREFIX}${randomUUID()}${BEACON_SUFFIX}`);
-  const token = `${BEACON_SCHEME}${target}`;
-  const server = try_bind_beacon(bind, target);
-  if (server === void 0) return void 0;
-  server.unref();
-  beacons.set(token, server);
-  ensure_exit_cleanup();
-  return token;
-}
-function resolve_own_start(probes = START_PROBES, platform2 = process.platform) {
-  const start = read_start(process.pid, probes);
-  if (start !== void 0 || platform2 === WINDOWS_PLATFORM) return start;
-  return open_beacon();
-}
-function is_valid_beacon_name(name) {
-  if (!name.startsWith(BEACON_PREFIX) || !name.endsWith(BEACON_SUFFIX)) return false;
-  const id = name.slice(BEACON_PREFIX.length, -BEACON_SUFFIX.length);
-  return id.length === BEACON_ID_LENGTH && BEACON_ID_PATTERN.test(id);
-}
-function beacon_target(token) {
-  if (!token.startsWith(BEACON_SCHEME)) return void 0;
-  const target = token.slice(BEACON_SCHEME.length);
-  if (path3.dirname(target) !== PLATFORM_TEMP_ROOT) return void 0;
-  return is_valid_beacon_name(path3.basename(target)) ? target : void 0;
-}
-function is_live_beacon(target) {
-  return spawnSync(process.execPath, ["-e", SOCKET_PROBE_SOURCE, target], {
-    stdio: "ignore",
-    timeout: PROBE_TIMEOUT_MS
-  }).status === 0;
-}
-function has_matching_start(pid, recorded_start, read2) {
-  const observed = read2(pid);
-  return observed === void 0 ? void 0 : observed === recorded_start;
-}
-function matches_recorded_start(pid, recorded_start, read2) {
-  const target = beacon_target(recorded_start);
-  return target === void 0 ? has_matching_start(pid, recorded_start, read2) : is_live_beacon(target);
-}
-var own_probe = /* @__PURE__ */ new Map();
-function own_start() {
-  if (!own_probe.has(process.pid)) own_probe.set(process.pid, resolve_own_start());
-  return own_probe.get(process.pid);
-}
-function own_fields() {
-  const start = own_start();
-  return { pid: process.pid, ...start !== void 0 && { process_start: start } };
-}
-function is_same_process(pid, recorded_start, read2 = read_start) {
-  if (pid === void 0 || !is_live_pid(pid)) return false;
-  if (recorded_start === void 0) return void 0;
-  return matches_recorded_start(pid, recorded_start, read2);
-}
-function is_own_process(pid, recorded_start) {
-  return pid === process.pid && recorded_start === own_start();
-}
-var process_identity = {
-  close_beacon,
-  is_live_pid,
-  is_own_process,
-  is_same_process,
-  open_beacon,
-  own_fields,
-  own_start,
-  read_start,
-  resolve_own_start
-};
-
 // scripts/run/run-carry.ts
 import { z as z5 } from "zod";
 
@@ -3300,6 +3524,8 @@ export {
   ALREADY_DONE_LABEL,
   has_any_label,
   has_label_name,
+  run_tail,
+  lane_background,
   lane_park,
   repo_party,
   FULL_PAGE_QUERY,
@@ -3310,8 +3536,8 @@ export {
   gh_failure,
   has_stderr_field,
   git_gh_exec,
-  lane_registry,
   process_identity,
+  lane_registry,
   run_invocation,
   run_carry,
   run_watcher_guard