agent-control-plane 0.3.0 → 0.6.0

package/tools/bin/agent-project-cleanup-session

@@ -1,513 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-usage() {
-  cat <<'EOF'
-Usage:
-  agent-project-cleanup-session --repo-root <path> [--runs-root <path> --history-root <path> --session <id>] [--worktree <path>] [--mode generic|issue|pr] [--remote <name>] [--remove-file <path>] [--keep-remote] [--allow-unmerged] [--skip-worktree-cleanup]
-
-Cleanup a project-lane worktree/branch using shared agent helpers, then archive
-the session run directory when one is provided.
-EOF
-}
-
-shared_agent_home="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
-repo_root="${AGENT_PROJECT_REPO_ROOT:-}"
-runs_root="${AGENT_PROJECT_RUNS_ROOT:-}"
-history_root="${AGENT_PROJECT_HISTORY_ROOT:-}"
-state_root="${AGENT_PROJECT_STATE_ROOT:-${F_LOSNING_STATE_ROOT:-}}"
-session=""
-worktree_path=""
-mode="generic"
-remote_name="origin"
-remove_file=""
-keep_remote="auto"
-allow_unmerged="auto"
-merged_base=""
-skip_worktree_cleanup="false"
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --repo-root) repo_root="${2:-}"; shift 2 ;;
-    --runs-root) runs_root="${2:-}"; shift 2 ;;
-    --history-root) history_root="${2:-}"; shift 2 ;;
-    --state-root) state_root="${2:-}"; shift 2 ;;
-    --session) session="${2:-}"; shift 2 ;;
-    --worktree) worktree_path="${2:-}"; shift 2 ;;
-    --mode) mode="${2:-}"; shift 2 ;;
-    --remote) remote_name="${2:-}"; shift 2 ;;
-    --remove-file) remove_file="${2:-}"; shift 2 ;;
-    --merged-base) merged_base="${2:-}"; shift 2 ;;
-    --keep-remote) keep_remote="true"; shift ;;
-    --allow-unmerged) allow_unmerged="true"; shift ;;
-    --skip-worktree-cleanup) skip_worktree_cleanup="true"; shift ;;
-    --help|-h) usage; exit 0 ;;
-    *) echo "Unknown argument: $1" >&2; usage >&2; exit 1 ;;
-  esac
-done
-
-if [[ -z "$repo_root" ]]; then
-  echo "--repo-root is required" >&2
-  usage >&2
-  exit 1
-fi
-
-case "$mode" in
-  generic|issue|pr) ;;
-  *)
-    echo "--mode must be generic, issue, or pr" >&2
-    exit 1
-    ;;
-esac
-
-if [[ -z "$worktree_path" && -z "$session" ]]; then
-  echo "Provide at least one of --worktree or --session" >&2
-  usage >&2
-  exit 1
-fi
-
-if [[ -n "$session" && ( -z "$runs_root" || -z "$history_root" ) ]]; then
-  echo "--runs-root and --history-root are required when --session is set" >&2
-  usage >&2
-  exit 1
-fi
-
-if [[ "$keep_remote" == "auto" ]]; then
-  case "$mode" in
-    issue) keep_remote="true" ;;
-    *) keep_remote="false" ;;
-  esac
-fi
-
-if [[ "$allow_unmerged" == "auto" ]]; then
-  case "$mode" in
-    issue|pr) allow_unmerged="true" ;;
-    *) allow_unmerged="false" ;;
-  esac
-fi
-
-meta_file=""
-branch_name=""
-result_file=""
-cleanup_warning=""
-cleanup_status="0"
-cleanup_error=""
-cleanup_mode="noop"
-orphan_fallback_used="false"
-active_tmux_session="false"
-archived_dir=""
-
-if [[ -n "$session" ]]; then
-  meta_file="${runs_root}/${session}/run.env"
-  if [[ -f "$meta_file" ]]; then
-    set -a
-    # shellcheck source=/dev/null
-    source "$meta_file"
-    set +a
-    branch_name="${BRANCH:-}"
-    result_file="${RESULT_FILE:-}"
-    if [[ -z "$worktree_path" ]]; then
-      worktree_path="${WORKTREE:-}"
-    fi
-  fi
-fi
-
-if [[ -z "$remove_file" ]]; then
-  remove_file="$result_file"
-fi
-
-if [[ -n "$session" ]] && tmux has-session -t "$session" 2>/dev/null; then
-  active_tmux_session="true"
-fi
-
-cleanup_tool="${shared_agent_home}/tools/bin/agent-cleanup-worktree"
-archive_tool="${shared_agent_home}/tools/bin/agent-project-archive-run"
-
-canonicalize_existing_dir() {
-  local target="${1:-}"
-  [[ -n "$target" && -d "$target" ]] || return 1
-  (
-    cd "$target"
-    pwd -P
-  )
-}
-
-canonicalize_dir_or_parent_join() {
-  local target="${1:-}"
-  local resolved=""
-
-  [[ -n "${target}" ]] || return 1
-
-  resolved="$(canonicalize_existing_dir "${target}" || true)"
-  if [[ -n "${resolved}" ]]; then
-    printf '%s\n' "${resolved}"
-    return 0
-  fi
-
-  (
-    cd "$(dirname "${target}")" 2>/dev/null
-    printf '%s/%s\n' "$(pwd -P)" "$(basename "${target}")"
-  ) || return 1
-}
-
-path_is_within_root() {
-  local target="${1:-}"
-  local root="${2:-}"
-  local target_canonical=""
-  local root_canonical=""
-
-  target_canonical="$(canonicalize_existing_dir "$target" || true)"
-  root_canonical="$(canonicalize_existing_dir "$root" || true)"
-  [[ -n "$target_canonical" && -n "$root_canonical" ]] || return 1
-  [[ "$target_canonical" == "$root_canonical" || "$target_canonical" == "$root_canonical"/* ]]
-}
-
-derive_state_root() {
-  if [[ -n "${state_root}" && -d "${state_root}" ]]; then
-    printf '%s\n' "${state_root}"
-    return 0
-  fi
-
-  if [[ -n "${runs_root}" && -d "${runs_root}" ]]; then
-    local candidate_root=""
-    candidate_root="$(cd "${runs_root}/.." 2>/dev/null && pwd -P || true)"
-    if [[ -n "${candidate_root}" && -d "${candidate_root}/state" ]]; then
-      printf '%s/state\n' "${candidate_root}"
-      return 0
-    fi
-  fi
-
-  return 1
-}
-
-resident_worktree_protected() {
-  local candidate_path="${1:-}"
-  local resolved_candidate=""
-  local resolved_state_root=""
-  local metadata_file=""
-  local resident_worktree=""
-  local resident_realpath=""
-  local resolved_resident=""
-  local resident_lane_kind=""
-  local resident_last_status=""
-
-  [[ -n "${candidate_path}" && -d "${candidate_path}" ]] || return 1
-  resolved_candidate="$(canonicalize_existing_dir "${candidate_path}" || true)"
-  [[ -n "${resolved_candidate}" ]] || return 1
-
-  resolved_state_root="$(derive_state_root || true)"
-  [[ -n "${resolved_state_root}" && -d "${resolved_state_root}/resident-workers/issues" ]] || return 1
-
-  for metadata_file in "${resolved_state_root}"/resident-workers/issues/*/metadata.env; do
-    [[ -f "${metadata_file}" ]] || continue
-    resident_worktree=""
-    resident_realpath=""
-    resident_lane_kind=""
-    resident_last_status=""
-    set +u
-    set -a
-    # shellcheck source=/dev/null
-    source "${metadata_file}"
-    set +a
-    set -u
-    resident_lane_kind="${RESIDENT_LANE_KIND:-}"
-    resident_last_status="${LAST_STATUS:-}"
-    if [[ "${resident_lane_kind}" != "recurring" && "${resident_last_status}" != "running" ]]; then
-      continue
-    fi
-    resident_worktree="${WORKTREE_REALPATH:-${WORKTREE:-}}"
-    [[ -n "${resident_worktree}" && -d "${resident_worktree}" ]] || continue
-    resolved_resident="$(canonicalize_existing_dir "${resident_worktree}" || true)"
-    [[ -n "${resolved_resident}" ]] || continue
-    if [[ "${resolved_candidate}" == "${resolved_resident}" ]]; then
-      return 0
-    fi
-  done
-
-  return 1
-}
-
-active_resident_run_worktree_protected() {
-  local candidate_path="${1:-}"
-  local resolved_candidate=""
-  local run_meta=""
-  local run_dir=""
-  local session_name=""
-  local resident_enabled=""
-  local resident_worktree=""
-  local runner_state_file=""
-  local runner_state=""
-  local active_session="false"
-  local resolved_resident=""
-
-  [[ -n "${candidate_path}" && -d "${candidate_path}" ]] || return 1
-  [[ -n "${runs_root}" && -d "${runs_root}" ]] || return 1
-
-  resolved_candidate="$(canonicalize_existing_dir "${candidate_path}" || true)"
-  [[ -n "${resolved_candidate}" ]] || return 1
-
-  for run_meta in "${runs_root}"/*/run.env; do
-    [[ -f "${run_meta}" ]] || continue
-
-    session_name=""
-    resident_enabled=""
-    resident_worktree=""
-    runner_state=""
-    active_session="false"
-
-    set +u
-    set -a
-    # shellcheck source=/dev/null
-    source "${run_meta}"
-    set +a
-    set -u
-
-    resident_enabled="${RESIDENT_WORKER_ENABLED:-no}"
-    [[ "${resident_enabled}" == "yes" ]] || continue
-
-    resident_worktree="${WORKTREE_REALPATH:-${WORKTREE:-}}"
-    [[ -n "${resident_worktree}" && -d "${resident_worktree}" ]] || continue
-    resolved_resident="$(canonicalize_existing_dir "${resident_worktree}" || true)"
-    [[ -n "${resolved_resident}" ]] || continue
-    [[ "${resolved_candidate}" == "${resolved_resident}" ]] || continue
-
-    run_dir="$(dirname "${run_meta}")"
-    runner_state_file="${run_dir}/runner.env"
-    if [[ -f "${runner_state_file}" ]]; then
-      set +u
-      set -a
-      # shellcheck source=/dev/null
-      source "${runner_state_file}"
-      set +a
-      set -u
-      runner_state="${RUNNER_STATE:-}"
-    fi
-
-    session_name="${SESSION:-}"
-    if [[ -n "${session_name}" ]] && tmux has-session -t "${session_name}" 2>/dev/null; then
-      active_session="true"
-    fi
-
-    if [[ "${runner_state}" == "running" || "${active_session}" == "true" ]]; then
-      return 0
-    fi
-  done
-
-  return 1
-}
-
-clear_resident_worktree_realpath_references() {
-  local removed_path="${1:-}"
-  local resolved_removed=""
-  local resolved_state_root=""
-  local metadata_file=""
-  local resident_realpath=""
-  local tmp_file=""
-  local metadata_worktree_realpath=""
-
-  [[ -n "${removed_path}" ]] || return 0
-
-  resolved_removed="$(canonicalize_dir_or_parent_join "${removed_path}" || true)"
-  [[ -n "${resolved_removed}" ]] || return 0
-
-  resolved_state_root="$(derive_state_root || true)"
-  [[ -n "${resolved_state_root}" && -d "${resolved_state_root}/resident-workers/issues" ]] || return 0
-
-  for metadata_file in "${resolved_state_root}"/resident-workers/issues/*/metadata.env; do
-    [[ -f "${metadata_file}" ]] || continue
-    metadata_worktree_realpath=""
-    set +u
-    set -a
-    # shellcheck source=/dev/null
-    source "${metadata_file}"
-    set +a
-    set -u
-    resident_realpath="${WORKTREE_REALPATH:-${metadata_worktree_realpath:-}}"
-    [[ -n "${resident_realpath}" ]] || continue
-    resident_realpath="$(canonicalize_dir_or_parent_join "${resident_realpath}" || true)"
-    [[ -n "${resident_realpath}" ]] || continue
-    if [[ "${resident_realpath}" != "${resolved_removed}" ]]; then
-      continue
-    fi
-
-    tmp_file="${metadata_file}.tmp.$$"
-    awk '
-      BEGIN { replaced = 0 }
-      /^WORKTREE_REALPATH=/ {
-        print "WORKTREE_REALPATH='\'''\''"
-        replaced = 1
-        next
-      }
-      { print }
-      END {
-        if (replaced == 0) {
-          print "WORKTREE_REALPATH='\'''\''"
-        }
-      }
-    ' "${metadata_file}" >"${tmp_file}"
-    mv "${tmp_file}" "${metadata_file}"
-  done
-}
-
-cleanup_with_branch_tool() {
-  local include_path="${1:-yes}"
-  local -a cleanup_args
-
-  cleanup_args=(--branch "$branch_name")
-  if [[ -n "$remote_name" ]]; then
-    cleanup_args+=(--remote "$remote_name")
-  fi
-  if [[ -n "$merged_base" ]]; then
-    cleanup_args+=(--merged-base "$merged_base")
-  fi
-  if [[ "$include_path" == "yes" && -n "$worktree_path" && -d "$worktree_path" ]]; then
-    cleanup_args+=(--path "$worktree_path")
-  fi
-  if [[ "$keep_remote" == "true" ]]; then
-    cleanup_args+=(--keep-remote)
-  fi
-  if [[ "$allow_unmerged" == "true" ]]; then
-    cleanup_args+=(--allow-unmerged)
-  fi
-
-  (
-    cd "$repo_root"
-    "$cleanup_tool" "${cleanup_args[@]}"
-  )
-}
-
-cleanup_orphan_worktree_dir() {
-  local worktree_root="${AGENT_PROJECT_WORKTREE_ROOT:-${F_LOSNING_WORKTREE_ROOT:-}}"
-  local worktree_canonical=""
-
-  [[ -n "$worktree_path" && -d "$worktree_path" ]] || return 1
-  [[ ! -e "$worktree_path/.git" ]] || return 1
-  [[ -n "$worktree_root" ]] || return 1
-  path_is_within_root "$worktree_path" "$worktree_root" || return 1
-
-  worktree_canonical="$(canonicalize_existing_dir "$worktree_path" || true)"
-  [[ -n "$worktree_canonical" ]] || return 1
-  rm -rf "$worktree_canonical"
-  git -C "$repo_root" worktree prune >/dev/null 2>&1 || true
-}
-
-worktree_path_is_registered() {
-  local candidate_path="${1:-}"
-  [[ -n "${candidate_path}" ]] || return 1
-
-  git -C "$repo_root" worktree list --porcelain 2>/dev/null \
-    | grep -F -x -q -- "worktree ${candidate_path}"
-}
-
-write_cleanup_warning_artifact() {
-  local target_dir=""
-  local notice_file=""
-  local cleanup_error_line=""
-  local recorded_at=""
-
-  [[ "${cleanup_status}" != "0" ]] || return 0
-
-  if [[ -n "${archived_dir}" && -d "${archived_dir}" ]]; then
-    target_dir="${archived_dir}"
-  elif [[ -n "${session}" && -n "${runs_root}" && -d "${runs_root}/${session}" ]]; then
-    target_dir="${runs_root}/${session}"
-  fi
-
-  [[ -n "${target_dir}" && -d "${target_dir}" ]] || return 0
-
-  cleanup_error_line="$(printf '%s' "${cleanup_error}" | tr '\n' ' ' | sed 's/  */ /g')"
-  recorded_at="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
-  notice_file="${target_dir}/cleanup-warning.txt"
-  {
-    printf 'recorded_at=%s\n' "${recorded_at}"
-    printf 'session=%s\n' "${session}"
-    printf 'mode=%s\n' "${mode}"
-    printf 'worktree=%s\n' "${worktree_path}"
-    printf 'branch=%s\n' "${branch_name}"
-    printf 'cleanup_mode=%s\n' "${cleanup_mode}"
-    printf 'cleanup_status=%s\n' "${cleanup_status}"
-    if [[ -n "${cleanup_error_line}" ]]; then
-      printf 'cleanup_error=%s\n' "${cleanup_error_line}"
-    fi
-  } >"${notice_file}"
-}
-
-if [[ "$active_tmux_session" == "true" ]]; then
-  cleanup_mode="deferred-active-session"
-elif [[ "$skip_worktree_cleanup" != "true" && -n "${worktree_path}" ]] \
-  && { resident_worktree_protected "${worktree_path}" || active_resident_run_worktree_protected "${worktree_path}"; }; then
-  cleanup_mode="protected-resident-worktree"
-elif [[ "$skip_worktree_cleanup" != "true" && -n "$branch_name" ]]; then
-  if cleanup_output="$(cleanup_with_branch_tool yes 2>&1)"; then
-    cleanup_mode="branch"
-  else
-    cleanup_status="$?"
-    cleanup_error="${cleanup_output}"
-    if cleanup_orphan_worktree_dir; then
-      orphan_fallback_used="true"
-      if cleanup_retry_output="$(cleanup_with_branch_tool no 2>&1)"; then
-        cleanup_mode="orphan-worktree"
-        cleanup_status="0"
-        cleanup_warning="${cleanup_error}"
-      else
-        cleanup_status="$?"
-        cleanup_error="${cleanup_error}"$'\n'"${cleanup_retry_output}"
-      fi
-    fi
-  fi
-elif [[ "$skip_worktree_cleanup" != "true" && -n "$worktree_path" ]] && worktree_path_is_registered "$worktree_path"; then
-  git -C "$repo_root" worktree remove "$worktree_path" --force || true
-  git -C "$repo_root" worktree prune
-  cleanup_mode="worktree"
-elif [[ "$skip_worktree_cleanup" != "true" ]] && cleanup_orphan_worktree_dir; then
-  orphan_fallback_used="true"
-  cleanup_mode="orphan-worktree"
-elif [[ "$skip_worktree_cleanup" == "true" ]]; then
-  cleanup_mode="archived-only"
-fi
-
-archive_output=""
-if [[ -n "$session" && "$active_tmux_session" != "true" ]]; then
-  archive_output="$(
-    "$archive_tool" \
-      --runs-root "$runs_root" \
-      --history-root "$history_root" \
-      --session "$session" \
-      --remove-file "${remove_file:-}"
-  )"
-  archived_dir="$(awk -F= '/^ARCHIVED_DIR=/{print substr($0, index($0, "=") + 1); exit}' <<<"${archive_output}")"
-fi
-
-if [[ "$skip_worktree_cleanup" != "true" && -n "$worktree_path" && ! -d "$worktree_path" ]]; then
-  clear_resident_worktree_realpath_references "$worktree_path"
-fi
-
-write_cleanup_warning_artifact
-
-printf 'SESSION=%s\n' "$session"
-printf 'MODE=%s\n' "$mode"
-printf 'WORKTREE=%s\n' "$worktree_path"
-printf 'BRANCH=%s\n' "$branch_name"
-printf 'KEEP_REMOTE=%s\n' "$keep_remote"
-printf 'ALLOW_UNMERGED=%s\n' "$allow_unmerged"
-printf 'SKIP_WORKTREE_CLEANUP=%s\n' "$skip_worktree_cleanup"
-printf 'ACTIVE_TMUX_SESSION=%s\n' "$active_tmux_session"
-printf 'CLEANUP_MODE=%s\n' "$cleanup_mode"
-printf 'ORPHAN_FALLBACK_USED=%s\n' "$orphan_fallback_used"
-printf 'CLEANUP_STATUS=%s\n' "$cleanup_status"
-if [[ -n "$meta_file" ]]; then
-  printf 'META_FILE=%s\n' "$meta_file"
-fi
-if [[ -n "$archive_output" ]]; then
-  printf '%s\n' "$archive_output"
-fi
-if [[ -n "$cleanup_warning" ]]; then
-  printf 'CLEANUP_WARNING=%s\n' "$(printf '%s' "$cleanup_warning" | tr '\n' ' ' | sed 's/  */ /g')"
-fi
-if [[ "$cleanup_status" != "0" && -n "$cleanup_error" ]]; then
-  printf 'CLEANUP_ERROR=%s\n' "$(printf '%s' "$cleanup_error" | tr '\n' ' ' | sed 's/  */ /g')"
-fi
-
-if [[ "$cleanup_status" != "0" ]]; then
-  exit "$cleanup_status"
-fi

package/tools/bin/agent-project-detached-launch

@@ -1,127 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=/dev/null
-source "${SCRIPT_DIR}/flow-config-lib.sh"
-CONFIG_YAML="$(resolve_flow_config_yaml "${BASH_SOURCE[0]}")"
-STATE_ROOT="$(flow_resolve_state_root "${CONFIG_YAML}")"
-AGENT_REPO_ROOT="$(flow_resolve_agent_repo_root "${CONFIG_YAML}")"
-REPO_ROOT="$(flow_resolve_repo_root "${CONFIG_YAML}")"
-
-usage() {
-  cat <<'EOF'
-Usage:
-  agent-project-detached-launch [--pending-key <kind-id>] <name> <command> [args...]
-
-Detach a worker bootstrap command from the current heartbeat process so the
-heartbeat can keep launching additional workers without waiting for expensive
-worktree/bootstrap/setup steps to finish.
-EOF
-}
-
-pending_key=""
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --pending-key)
-      pending_key="${2:-}"
-      shift 2
-      ;;
-    --help|-h)
-      usage
-      exit 0
-      ;;
-    *)
-      break
-      ;;
-  esac
-done
-
-if [[ $# -lt 2 ]]; then
-  usage >&2
-  exit 1
-fi
-
-launch_name="${1:-}"
-shift
-
-if [[ -z "${launch_name}" ]]; then
-  usage >&2
-  exit 1
-fi
-
-log_root="${ACP_LAUNCHER_LOG_ROOT:-${F_LOSNING_LAUNCHER_LOG_ROOT:-${STATE_ROOT}/launcher-logs}}"
-mkdir -p "${log_root}"
-
-safe_name="$(printf '%s' "${launch_name}" | tr '/[:space:]' '__' | tr -cd '[:alnum:]_.-')"
-if [[ -z "${safe_name}" ]]; then
-  safe_name="launch"
-fi
-
-timestamp="$(date -u +%Y%m%dT%H%M%SZ)"
-log_file="${log_root}/${timestamp}-${safe_name}.log"
-pending_file=""
-pending_dir="${ACP_PENDING_LAUNCH_DIR:-${F_LOSNING_PENDING_LAUNCH_DIR:-${STATE_ROOT}/pending-launches}}"
-if [[ -n "${pending_key}" ]]; then
-  mkdir -p "${pending_dir}"
-  pending_file="${pending_dir}/${pending_key}.pid"
-fi
-
-launch_cwd="${ACP_LAUNCH_CWD:-${F_LOSNING_LAUNCH_CWD:-}}"
-if [[ -z "${launch_cwd}" ]]; then
-  for candidate in "${AGENT_REPO_ROOT}" "${REPO_ROOT}" "${STATE_ROOT}" "${HOME:-}" "/"; do
-    if [[ -n "${candidate}" && -d "${candidate}" ]]; then
-      launch_cwd="${candidate}"
-      break
-    fi
-  done
-fi
-
-if [[ -z "${launch_cwd}" || ! -d "${launch_cwd}" ]]; then
-  echo "could not determine a stable working directory for detached launch" >&2
-  exit 1
-fi
-
-python_bin="${PYTHON_BIN:-$(command -v python3 || true)}"
-if [[ -z "${python_bin}" ]]; then
-  echo "python3 is required for detached launch" >&2
-  exit 1
-fi
-
-launch_pid="$(
-  "${python_bin}" - "${log_file}" "${pending_file}" "${launch_cwd}" "$@" <<'PY'
-import subprocess
-import sys
-from pathlib import Path
-
-log_file = Path(sys.argv[1])
-pending_file = sys.argv[2]
-launch_cwd = sys.argv[3]
-argv = sys.argv[4:]
-
-with log_file.open("ab", buffering=0) as log_handle:
-    proc = subprocess.Popen(
-        argv,
-        stdin=subprocess.DEVNULL,
-        stdout=log_handle,
-        stderr=subprocess.STDOUT,
-        cwd=launch_cwd,
-        start_new_session=True,
-    )
-
-if pending_file:
-    Path(pending_file).write_text(f"{proc.pid}\n", encoding="utf-8")
-
-print(proc.pid)
-PY
-)"
-
-printf 'LAUNCH_MODE=detached\n'
-printf 'LAUNCH_NAME=%s\n' "${launch_name}"
-printf 'LAUNCH_PID=%s\n' "${launch_pid}"
-printf 'LAUNCH_LOG=%s\n' "${log_file}"
-printf 'LAUNCH_CWD=%s\n' "${launch_cwd}"
-if [[ -n "${pending_file}" ]]; then
-  printf 'LAUNCH_PENDING_FILE=%s\n' "${pending_file}"
-fi