diff --git a/.gitattributes b/.gitattributes
index 4d910d86d..e586889cc 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,4 +1,5 @@
 *	text	working-tree-encoding=ISO8859-1
 *.pem   text working-tree-encoding=UTF-8
-*.png   binary  working-tree-encoding=UTF-8
+*.png   binary
 *.gif binary
+*.pax.Z binary
diff --git a/.pinned b/.pinned
new file mode 100644
index 000000000..e69de29bb
diff --git a/.version b/.version
new file mode 100644
index 000000000..f75f81603
--- /dev/null
+++ b/.version
@@ -0,0 +1 @@
+0.3.0-dt-stable
diff --git a/README.md b/README.md
index fe528570f..9c59f8867 100644
--- a/README.md
+++ b/README.md
@@ -1,90 +1,98 @@
-# meta
+# meta-dt
+A reworking of the main meta project to add additional package management facilities, similar to utilities like apt, dpkg, yum, yast2, emerge .... just written in pure shell script (and a tiny bit of REXX) to remove any pre-reqs (like python/perl/bash etc).
+This fork is designed for everyday usage of the zos Open Tools ports within the USS environment or for those who wish to download the tools; users who are interested in building and/or porting packages from scratch should use the main release of meta at this time.
 
-Meta repository to tie together the various underlying z/OS Open Source tools repositories here.
+## Installation
+- Download the pax to a suitable location (for example /tmp).
+- Expand the pax using the command ```pax -rvf <filename>.pax```.  This will expand the pax to the current directory, listing the various included files as it does so.
+- From the ```meta-<ver>/bin``` directory run the following command, answering the questions appropriately:
+```
+>zopen init
+```
 
-View our documentation at https://zosopentools.github.io/meta/.
 
-## Background
+## Pre-config
+It is advised to have the following set on the system to ensure correct operation:
+```
+export _BPXK_AUTOCVT=ON
+export _CEE_RUNOPTS="$_CEE_RUNOPTS FILETAG(AUTOCVT,AUTOTAG) POSIX(ON)"
+export _TAG_REDIR_ERR=txt
+export _TAG_REDIR_IN=txt
+export _TAG_REDIR_OUT=txt
+```
 
-There are some key 'foundational' Open Source technologies needed to port software. The goal of this set of repositories is to provide minimal 'port' repositories
-that can be used to get a foundational software package building on z/OS.
-We are starting with what we view as some 'foundational' technologies. One is the stack of technology to be able to build [zsh](https://sourceforge.net/projects/zsh/postdownload). Another is to
-be able to build [protocol buffers](https://github.com/protocolbuffers/protobuf/releases).
+## Sample usage
+```
+>./zopen init
+>. $HOME/.zopen-config
+>./zopen list --installed
+>zopen install which
+>zopen list --installed
+>which which
+>zopen upgrade
+```
 
-But - there is a _transitive closure_ problem to address with porting a software package, namely understanding what packages are pre-requisites
-for the software package you want to port. As an example, for zsh, we see the following:
+## Important usage notes
+- On first run, ```zopen init``` will copy this forked version of meta into the "package" area of zopen (ie. where packages are expanded and accessed from).  It will also be pinned to this release to prevent any possible updates from the "real" meta package. Removing the .pinned file from the meta-dt directory will allow for the main meta port to be installed however this will cause incompatabilities if run.
 
-zsh requires autoconf to configure the build scripts, GNU make to run Makefiles, ncurses
-zsh is easier to develop (but doesn't require) curl and git natively on z/OS, and GNU techinfo for documentation.
+- Remote respositores utilise the suffix ```port``` - where required, packages should be specified **withOUT** the suffix. eg using ```zopen install which``` rather than ```zopen install whichport```
 
-autoconf requires m4, automake, and GNU make
-m4 requires a c99 compiler with c11 features, so make sure you have the latest C/C++ compilers installed on your system.
+## System install
+- Selecting ```'/' ``` as the root filesystem will allow the tools to be available system wide for all users who configure their usage. The install needs to be done by a sysadmin [or someone with sufficient rights using the sudo port for example] as the installer will write files to the /usr tree and configuration information to /etc.  The installing sysadmin will have a `.zopen-config` generated in their ```$HOME``` directory, specific to their install properties - their GitHub Access Token for example.  There will also be a "skeleton" configuration file written as ```/etc/skel/.zopen-config``` - this can be used as a template for individual users.  The skeleton template does not contain the installer's GH token (if configured during install) but inserts a placeholder should the user have their own GH token.  Copying the ```/etc/skel/.zopen-config``` to a user's $HOME directory will allow them to source it easily on login using ```. $HOME/.zopen-config```.
+- Removing zopen and the z/OS Open Tools once installed involves: uninstalling all installed packages; removing any copies of ```.zopen-config```; removing the configured zopen root directory (by default ```/usr/local/zopen``` but is set during installation); and then running a command to find any final orphaned symlinks on the system, such as: ```/bin/find $ZOPEN_ROOTFS -type l -exec test ! -e {} \; -print```  where $ZOPEN_ROOTFS is '/' [replace `-print` with `rm -rf` to actually remove symlinks, the example command should only list what was found - care should be taken when removing any files with sysadmin authority to prevent removing critial files!]
 
-GNU make requires GNU m4, automake, autoconf, Perl, and a C compiler that is gcc compatible.
 
-## Order to Build _from scratch_
+## Problem resolution
+If the meta package does get updated to a non-dt version, then running ```./zopen alt meta -s``` from the meta-dt/bin directory within the z/OS Open Tools root filesystem should allow selection of the dt-forked meta; running any other non-forked zopen commands might break the installation or cause unexpected behaviour! 
+zopen commands take a ```--verbose``` parameter to produce additional messages that can be used to aid problem diagnosis.
 
-If you want to build the tools from scratch and not use the binary pax files available, you will want
-to tackle this in a particular order.
-First, you need to have some tools installed on your system:
+## Basic command introduction
+Most commands have extended help available using the ```--help``` parameter.  The following usage guidance should be sufficient to get a system running
 
-### System Prerequisites
+>zopen init
 
-Use `zopen-setup` to download the bootstrap environment.  This will provide you with the
-minimum required set of tools to get started.  Otherwise you can download the tools individually at the below links.
+Used to initialise a z/OS Open Tools environment. By default, this will create a ```zopen``` directory in your ```$HOME``` directory as the root filesystem (rootfs).  The rootfs holds the various packages, configuration and environment for z/OS Open Tools packages - removing this directory will revert the system without a trace.  A z/OS Open Tools main configuration file is generated in ```$HOME/.zopen-config``` - to enable the z/OS Open Tools, this will either need to be sourced after logon to the system or the following line can be added to ```$HOME/.profile``` (or .bash_profile or...) to automatically source the z/OS Open Tools configuration file
+>[ -e "$HOME/.zopen-config" ] && . $HOME/.zopen-config
+It is possible to reinitialize a system using the ```re-init``` option - doing so will remove the previous configuration though the rootfs can overlap the old filesystem to reuse installed and/or cached packages for example.  Initialisation on a system that has previously had a z/OS Open Tools configuration should allow some parameters to be copied across, such as Github tokens.
 
-| Project | License | Download link |
-|---------|---------|------------------------|
-| [gnu make 4.1](https://www.gnu.org/software/make/) | [GPL V3](https://www.gnu.org/licenses/gpl-3.0.html) | [z/OS Open Tools release](https://github.com/ZOSOpenTools/makeport/releases/tag/boot) |
-| [IBM XL C/C++ V2.4.1](https://www-40.ibm.com/servers/resourcelink/svc00100.nsf/pages/xlCC++V241ForZOsV24) | IBM [^ibm] | [ibm.com web download](https://www.ibm.com/marketing/iwm/iwm/web/dispatcher.do?source=swg-zosxlcc) |
-| [git](https://git.kernel.org/pub/scm/git/git.git/) | [LGPL V2.1](https://git.kernel.org/pub/scm/git/git.git/tree/LGPL-2.1) | [z/OS Open Tools release](https://github.com/ZOSOpenTools/gitport/releases/tag/boot)  |
-| [curl](https://github.com/curl/curl) | [curl-license](https://github.com/curl/curl/blob/master/COPYING) | [z/OS Open Tools release](https://github.com/ZOSOpenTools/curlport/releases/tag/boot) |
-| [gunzip](https://www.gnu.org/software/gzip/) | [GPL V3](https://www.gnu.org/licenses/gpl-3.0.html) | [z/OS Open Tools release](https://github.com/ZOSOpenTools/unzipport/releases/tag/boot) |
+>zopen install <package>...
 
-[^ibm]: a no-charge add-on feature for clients that have enabled the XL C/C++ compiler (an optionally priced feature) on z/OS
+Used to install a z/OS Open Tools package.  By default, the latest version is installed although options are available to install specific versions, tags or to pick from a selection [see ```--help``` for more]
 
-### Recommended software
+>zopen upgrade
 
-| Project | License | Download link |
-|---------|---------|------------------------|
-| [bash](https://www.gnu.org/software/bash/) | [GPL V3](https://www.gnu.org/licenses/gpl-3.0.html) | [z/OS Open Tools release](https://github.com/ZOSOpenTools/bashport/releases/) |
+Used to upgrade z/OS Open Tools packages.  Without parameters, all installed packages will be upgraded; individual packages can be specified on the command line to upgrade only those packages.  Packages can be "pinned" to prevent upgrading in case a later release is found to be broken or incompatible - creating a ```.pinned``` file in the package directory prevents the upgrade; removing the file allows upgrades to occur.
 
-Both IBM and Rocket provide supported versions of the software above for a fee.
+>zopen clean [--cache] [--unused] [--dangling] [--all]
 
-Taking the defaults will mean there are less variables for you to configure. We recommend you structure your sandbox as follows:
+Used to remove resources on the system.  zopen will retain old versions of packages to allow for switching versions or quick re-installs; downloaded pax files are held in a cache while the specific version files are maintained in the directory configured during initialisation.  Using the ```clean``` option removes those unused resources.  In addition, zopen utilises symlinks for maintaining the appropriate file structure - should a problem occur during package installation, removal or version change, danling symlinks might be present; the ``--dangling`` option will (slowly) analyse the rootfs and prune any dangling symlinks.
 
-- Have the root of your development file system be `$HOME/zopen` (you will want to have several gigabytes of storage for use - we recommend at least 15GB)
-- Have sub-directories called _boot_, _prod_, _dev_.
-  - _boot_: sub-directory for each tool required to bootstrap (make, git, curl, gunzip, m4)
-  - _prod_: sub-directory for tools to be installed once built. These tools will be used by downstream software, e.g. make build process will use the Perl prod build
-  - _dev_: sub-directory for tools you are building
+>zopen alt [package] [-s]
 
-### Build Order
+Used to list versions of a package if there are multiple versions present; using the ```-s``` parameter allows for the active version to be changed
 
-The tools have dependencies on other tools, and there are also typically 2 ways the tools are packaged:
+>zopen remove <package>...
 
-- one that is pre-configured and therefore doesn't need autoconf/automake and associated tools
-- one that is not pre-reconfigured and therefore does require autoconf/automake and associated tools
+Removes a package from the system, leaving the version on the system for re-use later; the ```---purge`` directory will also remove the versioned directory, requiring a potential download and/or an unpax to occur to re-install that version
 
-To build from scratch, start with the tarballs of the following tools:
 
-| Project | License | Pre-requisites |
-|---------|---------|------------------------|
-| [m4](https://www.gnu.org/software/m4/m4.html) | [GPL V3 ](https://www.gnu.org/licenses/gpl-3.0.html) | m4, curl in boot and xlclang installed on the system |
-| [perl](https://dev.perl.org/) | [GPL V3 ](https://www.gnu.org/licenses/gpl-3.0.html) | additionally requires make, git in boot and m4 in prod |
-| [make](https://www.gnu.org/software/make/) | [GPL V3 ](https://www.gnu.org/licenses/gpl-3.0.html) | perl in prod for running test cases |
-| [zlib](https://zlib.net/) | [zlib license](https://zlib.net/zlib_license.html) | make in prod |
-| [autoconf](https://www.gnu.org/software/autoconf/) | [GPL V3](https://www.gnu.org/licenses/gpl-3.0.html) | libz in prod |
-| [automake](https://www.gnu.org/software/automake/) | [GPL V3](https://www.gnu.org/licenses/gpl-3.0.html) | autoconf in prod |
+>zopen list [--installed]
 
-Once you either have these tools built, or have downloaded a pre-built pax file for the build, you may want to build other tools.
-Each tool has a _buildenv_ file and one of the entries will describe the tools it requires to build, depending
-on where the source is from (currently TARBALL or GIT clone). So for example m4 requires:
+With no parameters, will list the available packages against the currently installed versions; more usefully, using the ```--installed``` parameter lists the actually locally-installed packages rather than all potential packages
 
-`ZOPEN_TARBALL_DEPS="curl gzip make m4"`
+>zopen search <package>
 
-and:
+Searches the remote repositiory for the specified package, returning appropriate meta-data about the package if found
+
+>zopen query <option>
+
+Queries the local z/OS Open Tools sytem. See ```---help``` for more details
+
+
+
+
+### Useful resources
+- View the z/OS Open Tools project home: https://github.com/ZOSOpenTools
+- View the main Meta documentation at https://zosopentools.github.io/meta/
 
-`ZOPEN_GIT_DEPS="git make m4 help2man perl makeinfo xz autoconf automake gettext"`
 
-If you want to build from the `git` clone, you can see you will need to have more software pre-installed.
diff --git a/bin/lib/common.inc b/bin/lib/common.inc
old mode 100644
new mode 100755
index 19de20c9f..cfa827d67
--- a/bin/lib/common.inc
+++ b/bin/lib/common.inc
@@ -1,11 +1,39 @@
 #!/bin/sh
-defineColors() 
+export ZOPEN_CLEANUP="stty echo" # set this as a default to ensure line visibility!
+addCleanupTrapCmd(){
+  newCmd=$(echo "$1" | sed -e 's/^[ ]*//' -e 's/[ ]*$//')
+  if [ -z "$ZOPEN_CLEANUP" ]; then
+    export ZOPEN_CLEANUP="$newCmd"
+  else
+    export ZOPEN_CLEANUP="$(deleteDuplicateEntriesRedux "$ZOPEN_CLEANUP; $newCmd" ";")"
+  fi
+}
+cleanupFunction() {
+  [ -n "$ZOPEN_CLEANUP" ] && $(eval "$ZOPEN_CLEANUP" 2>/dev/null)
+  trap - EXIT INT TERM QUIT HUP
+  unset ZOPEN_CLEANUP
+}
+trap "cleanupFunction" EXIT INT TERM QUIT HUP
+
+defineANSI() 
 {
+  # Standard tty codes
+  ESC="\047"
+  ERASELINE="${ESC}[2K"
+  CRSRHIDE="${ESC}[?25l"
+  CRSRSHOW="${ESC}[?25h"
+
+  # Color-type codes, needs explicit terminal settings
   if [ ! "${_BPX_TERMPATH-x}" = "OMVS" ] && [ -z "${NO_COLOR}" ] && [ ! "${FORCE_COLOR-x}" = "0" ] && [ -t 1 ] && [ -t 2 ]; then
     esc="\047"
+    BLACK="${esc}[30m"
     RED="${esc}[31m"
     GREEN="${esc}[32m"
     YELLOW="${esc}[33m"
+    BLUE="${esc}[34m"
+    MAGENTA="${esc}[35m"
+    CYAN="${esc}[36m"
+    GRAY="${esc}[37m"
     BOLD="${esc}[1m"
     UNDERLINE="${esc}[4m"
     NC="${esc}[0m"
@@ -13,14 +41,64 @@ defineColors()
 # unset esc RED GREEN YELLOW BOLD UNDERLINE NC
 
     esc=''
+    BLACK=''
     RED=''
     GREEN=''
     YELLOW=''
+    BLUE=''
+    MAGENTA=''
+    CYAN=''
+    GRAY=''
     BOLD=''
     UNDERLINE=''
     NC=''
   fi
 }
+ansiline(){
+  deltax=$1
+  deltay=$2
+  echostr=$3
+  if [ $deltax -gt 0 ]; then
+    echostr="${ESC}[${deltax}A$echostr"
+  elif [ $deltax -lt 0 ]; then
+    echostr="${ESC}[$(expr $deltax \* -1)A$echostr"
+  fi
+  if [ $deltay -gt 0 ]; then
+    echostr="${ESC}[${deltax}C$echostr"
+  elif [ $deltay -lt 0 ]; then
+    echostr="${ESC}[$(expr $deltax \* -1)D$echostr"
+  fi
+ /bin/echo "${echostr}"
+
+}
+
+getScreenCols(){
+  # Note tput does not handle ssh sessions too well...
+  stty | awk -F'[/=;]' '/columns/ { print $4}' | tr -d " "
+}
+
+zosfind(){
+  # Use the standard z/OS find utility; If the findutils package is installed,
+  # the installed find command takes precedence but is not compatible with the
+  # standard zos find [regex searches for "-name" are not allowed, but
+  # "-wholename" is not available on standard zosfind. For the tooling to be
+  # consistent across platforms (where findutils is/is not installed) use the
+  # standard zos version
+  /bin/find $*
+}
+
+findrev () {
+  haystack="$1"
+  needle="$2"
+  while [[ "$haystack" != "" && "$haystack" != "/" && "$haystack" != "./" && ! -e "$haystack/$needle" ]]; do
+    haystack=${haystack%/*}
+  done
+  echo "$haystack"
+}
+
+strtrim(){
+  echo "$1" | sed -e 's/^[ ]*//' -e 's/[ ]*$//'
+}
 
 defineEnvironment()
 {
@@ -41,6 +119,9 @@ defineEnvironment()
 
   # Use /bin/cat as the pager in case xlclang help is displayed, we don't want to wait for input
   export PAGER=/bin/cat
+
+  # Set a default umask of full permissions to owner and group.
+  umask 0002
 }
 
 #
@@ -49,26 +130,315 @@ defineEnvironment()
 #
 printColors()
 {
-  /bin/echo "$1"
+  /bin/echo "$@"
+}
+
+mutexReq(){
+  mutex=$1
+  lockdir="$ZOPEN_ROOTFS/var/lock"
+  [ -e lockdir ] || mkdir -p $lockdir
+  mutex="$lockdir/$mutex"
+  mypid=$(exec sh -c 'echo $PPID')
+  if [ -e "$mutex" ]; then
+    lockedpid=$(cat $mutex)
+    { [ ! "$lockedpid" = "$mypid" ] && [ ! "$lockedpid" = "$PPID" ]; } && echo "Aborting, Process '$lockedpid' holds the '$2' lock: '$mutex'" && exit -1
+  fi
+  addCleanupTrapCmd "rm -rf $mutex"
+  echo "$mypid" > $mutex
+}
+mutexFree(){
+  mutex=$1
+  lockdir="$ZOPEN_ROOTFS/var/lock"
+  mutex="$lockdir/$mutex"
+  [ -e "$mutex" ] && rm -f $mutex
+}
+# Calculate the relative path from $1 to $2
+relativePath(){
+  sourcePath=$1
+  targetPath=$2
+  currentIFS="$IFS"
+  IFS="/"
+  relativePath=''
+  set -- $targetPath
+  for elem in $sourcePath; do
+    if [ -z "$relativePath" ]; then
+      if [ -z "$elem" ]; then
+        relativePath="$1"
+      elif [ "$1" = "$elem" ]; then
+      else
+        relativePath="../$1"
+      fi
+    else
+      if [ -n "$elem" ]; then
+        relativePath="../$relativePath"
+      else
+        relativePath="$relativePath/$1"
+      fi
+    fi
+    if [ $# -gt 0 ]; then
+      shift
+    fi
+  done
+  # if the target is longer than the source, there might be some additional
+  # elements in the shifted $0 to append
+  if [ $# -gt 0 ]; then
+     relativePath=$relativePath/$(echo $* | sed "s/ /\//g")
+  fi
+
+  IFS="$currentIFS"
+  echo "$relativePath"
+}
+relativePath2(){
+  sourcePath=$1
+  targetPath=$2
+  currentIFS="$IFS"
+  IFS="/"
+  relativePath=''
+  set -- $targetPath
+  for elem in $sourcePath; do
+      if [ -z "$relativePath" ]; then
+        if [ "$1" = "$elem" ]; then
+            shift
+            continue
+        else
+          relativePath="../$elem"
+        fi
+      else
+        if [ -z "$1" ]; then
+          relativePath="$relativePath/$elem"
+        else
+          relativePath="../$relativePath/$elem"
+        fi
+      fi
+    if [ $# -gt 0 ]; then
+      shift
+    fi
+  done
+  # if the target is longer than the source, there might be some additional
+  # elements in the shifted $0 to append
+  if [ $# -gt 0 ]; then
+     relativePath=$relativePath/$(echo $* | sed "s/ /\//g")
+  fi
+  IFS="$currentIFS"
+  echo "$relativePath"
+}
+
+# Merges a package directory's symlinks into the main zopen root filesystem
+mergeIntoSystem(){
+  name=$1          # Name of the package being processed
+  versioneddir=$2  # The directory where the unpax occurred
+  rootfs="$3"
+
+  targetdir="$rootfs/usr"     # The main rootfs/usr location
+
+  printVerbose "Calculating the offset path to store from root"
+  offset=$(dirname "${versioneddir#$rootfs/}")
+  version=$(basename $versioneddir)
+  tmptime=$(date +%Y%m%d%H%M%S)
+  processingDir="$rootfs/tmp/zopen.$tmptime"
+  printVerbose "Temporary processing dir evaluated to: $processingDir"
+
+  virtualStore="$processingDir/$offset"
+  printVerbose "Creating virtual store at: $virtualStore"
+  mkdir -p "$virtualStore"
+
+  printVerbose "Moving from main store location (unpax-dir) to processing store"
+  mv "$versioneddir" "$virtualStore"
+
+  printVerbose "Creating main linked directory in store"
+  $(cd "$virtualStore" && ln -s "$version" "$name")
+
+  printVerbose "Creating virtual root directory structure"
+  mkdir -p "$processingDir/usr"
+
+  printVerbose "Generating relative symlinks in processing location"
+  relpath=$(relativePath2 "$virtualStore/$name" "$processingDir/usr")
+  [ "$relpath" = "/" ] && printError "Relative path calculated as root directory itself!?!"
+
+  printVerbose "Generating symlink tree"
+  
+  printVerbose "Creating directory structure"
+  curdir="$PWD"
+  cd "$virtualStore/$name"
+   # since 'ln *' doesn't invoke globbing to allow multiple files at once,
+   # abuse the Recurse option; this results in "already exists" errors but 
+   # ignore them as the first call should generate the correct link but 
+   # subsequent calls would generate a symlink that has incorrect dereferencing 
+   # and ignoring them is actually faster than individually creating the links!
+  zosfind . -type d | sort -r | while read dir; do
+    dir=$(echo "$dir" | sed "s#^./##")
+    printVerbose "Processing dir: $dir" 
+    [ $dir = "." ] && continue;
+    mkdir -p "$processingDir/usr/$dir"
+    cd "$processingDir/usr/$dir"
+    dirrelpath=$(relativePath2 "$virtualStore/$name/$dir" "$processingDir/usr/$dir")
+    ln -Rs "$dirrelpath/" "." 2>/dev/null
+  done 
+
+  printVerbose "Moving unpaxed processing-directory back to main rootfs store"
+  # this *must* be done before the merge step below or relative symlinks can't
+  # work
+  versioneddirname=$(basename "$versioneddir")
+  mv "$virtualStore/$versioneddirname" "$rootfs/$offset"
+
+  tarfile="$name.usr.tar"
+  printVerbose "Merge symlinks into main filesystem using tmp tar file $tarfile"
+  
+  printVerbose "Generating intermediary tar file"
+  # Need '-S' to allow long symlinks
+  $(cd "$processingDir" && tar -S -cf "$tarfile" "usr")
+
+  printVerbose "Generating listing for remove processing (including main symlink)"
+  listing=$(tar tf "$processingDir/$tarfile" 2>/dev/null| sort -r)
+  echo "Installed files:" > "$versioneddir/.links"
+  echo "$listing" >>  "$versioneddir/.links"
+  
+  printVerbose "Extracting tar to rootfs"
+  cd "$processingDir" && tar xf "$tarfile" -C "$rootfs" 2>/dev/null
+
+  printVerbose "Cleaning temp resources"
+  rm -rf "$processingDir" 2>/dev/null
+
+  printInfo "- Integration complete"
+  return 0
+}
+
+# The following function will remove any orphaned symlinks left after either:
+# - a different version has been installed (where the old symlinks are not reused for
+#   that different version  version ie. the file has been removed from updated version
+# - the main package->version-dir symlink has been removed (which renders any symlinks to
+#   it as dangling so removable)
+unsymlinkFromSystem(){
+  pkg=$1
+  rootfs=$2
+  dotlinks=$3
+  if [ -e "$dotlinks" ]; then
+    printInfo "- Checking for obsoleted files in $rootfs/usr/ tree from $pkg"
+    # Use sed to skip header line in .links file
+    # Note that the contents of the links file are ordered such that
+    # processing occurs depth-first; if, after removing orphaned symlinks,
+    # a directory is empty, then it can be removed.
+    nfiles=$(sed '1d;$d' "$dotlinks" | wc -l  | tr -d ' ')
+    flecnt=0
+    pct=0
+
+    printVerbose "Creating Temporary dirname file"
+    tempDirFile="$ZOPEN_ROOTFS/tmp/zopen.rmdir.$RANDOM"
+    tempTrash="$tempDirFile.trash"
+    [ -e "$tempDirFile" ] && rm -f "$tempDirFile" >/dev/null 2>&1
+    touch "$tempDirFile"
+    addCleanupTrapCmd "rm -rf $tempDirFile"
+    printVerbose "Using temporary file $tempDirFile"
+    printInfo "- Checking ${nfiles} potential links"
+
+    rm_fileprocs=15
+    [ -e "$rootfs/etc/zopen/rm_fileprocs" ] && rm_fileprocs=$(cat "$rootfs/etc/zopen/rm_fileprocs")
+    threshold=$(( nfiles / rm_fileprocs))
+    threshold=$(( threshold + 1 ))
+    printVerbose "Threshold of files per worker [files/procs] calculated as: $threshold"
+    [ $threshold -le 50 ] && threshold=50 && printVerbose "Threshold below min: using 50" # Don't spawn too many
+    printVerbose "Starting spinner..."
+    progressHandler "spinner" "- Complete" &
+    ph=$!
+    killph="kill -HUP $ph"
+    addCleanupTrapCmd "$killph"
+
+    printVerbose "Spawning as subshell to handle threading"
+    # Note that this all must happen in a subshell as the above started
+    # progressHandler is a signal-terminated process - and a wait issued in 
+    # the parent will never complete until that ph is signalled/terminated!
+    deletethreads=$(
+      tid=0
+      filenames=""
+      while read filetounlink; do
+        tid=$(( tid + 1 ))
+        filenames="$filenames\n$filetounlink"
+        if [ "$(( tid % threshold ))" -eq 0 ]; then
+          deletethread "$filenames" "$tempDirFile" &
+          printVerbose "Started delete thread: $!"
+          filenames=""
+        fi
+      done <<EOF
+$(sed '1d;$d' "$dotlinks")
+EOF
+      if [ -n "$filenames" ]; then
+        # Handle when there are not enough to trigger the threshold of a new thread above,
+        # there will still be items in the "array"
+        deletethread "$filenames" "$tempDirFile" #&
+        printVerbose "Started delete thread: $!"
+      fi
+      wait 
+    )
+    $killph 2>/dev/null  # if the timer is not running, the kill will fail
+    if [ -e "$tempDirFile" ]; then
+      ndirs=$(cat "$tempDirFile" | uniq | wc -l  | tr -d ' ')
+      printInfo "- Checking ${ndirs} dir links"
+      for d in $(cat "$tempDirFile" | uniq | sort -r) ; do 
+        [ -d "$d" ] && rmdir "$d" >/dev/null 2>&1
+      done
+    fi
+  else
+    printError "Could not locate list of current links to verify, dangling links might be present; run 'zopen clean -d'"
+  fi
+}
+
+deletethread(){
+  filestodelete="$1"
+  tempDirFile="$2"
+  echo "$filestodelete"| while read filetounlink; do
+    deletetask "$tempDirFile" "$filetounlink" 
+  done
+}
+
+deletetask () {
+    tempDirFile="$1"
+    filename="$2"
+    [ -z "$filename" ] && return 0
+    filename=$(echo "$filename" | sed 's/\(.*\).symbolic.*/\1/')
+    filename="$ZOPEN_ROOTFS/$filename"
+    if [ -d "$filename" ]; then
+        # Add to the queue for checking once files are gone if unique
+        ispresent=$(grep "^$filename[ ]*$" "$tempDirFile")
+        if [ -z "$ispresent" ]; then
+          echo " $filename " >> "$tempDirFile"
+        else
+          alreadyfound=""
+        fi
+    elif [ -L "$filename" ]; then
+      if [ ! -f "$filename" ]; then
+        # the linked-to file no longer exists (ie. the symlink is dangling)
+        rm -f "$filename" >/dev/null 2>&1
+      fi
+    else 
+      echo "Unprocessable file: $filename" >> "$tempTrash" 
+    fi
 }
 
 zopenInitialize()
 {
   defineEnvironment
-  defineColors
+  defineANSI
   processConfig
+
+  ZOPEN_JSON_CACHE_URL="https://zosopentools.github.io/meta/api/zopen_releases.json"
 }
 
 printVerbose()
 {
+  [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
   if ${verbose}; then
     printColors "${NC}${GREEN}${BOLD}VERBOSE${NC}: '${1}'" >&2
   fi
+  [ ! -z "$xtrc" ] && set -x
+  return 0;
 }
 
 printHeader()
 {
+  [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
   printColors "${NC}${YELLOW}${BOLD}${UNDERLINE}${1}${NC}" >&2
+  [ ! -z "$xtrc" ] && set -x
+  return 0;
 }
 
 runAndLog()
@@ -82,6 +452,84 @@ runAndLog()
   return $rc
 }
 
+runLogProgress(){
+  printVerbose "$1"
+  if [ -n "$2" ]; then
+    printInfo "- $2"
+  else
+    printInfo "- Running"
+  fi
+  if [ -n "$3" ]; then
+    completeText="$3"
+  else
+    completeText="Complete"
+  fi
+  progressHandler "spinner" "- $completeText" &
+  ph=$!
+  killph="kill -HUP $ph"
+  addCleanupTrapCmd "$killph"
+  eval "$1"
+  rc=$?
+  if [ ! -z "${SSH_TTY}" ]; then
+    chtag -r $SSH_TTY
+  fi
+  $killph 2>/dev/null  # if the timer is not running, the kill will fail
+  return $rc
+}
+
+spinloop(){
+  # in the absence of generic ms/ns reporting, spin-loop instead - not ideal
+  # but without pre-reqing packages...
+  i=$1
+  while [ $i -ge 0 ]; do
+    true > /dev/null
+    i=$(( i - 1 ))
+  done
+}
+progressNetwork(){
+  # Loop until signal received
+  icon="-----"
+  ansiline 0 0 "$icon"
+  while : ; do
+    spinloop 1000
+    case "$icon" in
+      '-----') icon='>----';; '>----') icon='->---';; '->---') icon='-->--';; '-->--') icon='--->-';; '--->-') icon='---->';;
+      '---->') icon='----<';; '----<') icon='---<-';; '---<-') icon='--<--';; '--<--') icon='-<---';; '-<---') icon='<----';; '<----') icon='-----';;
+    esac
+    ansiline 1 -1 "$icon"
+  done
+}
+progressSpinner(){
+  # Loop until signal received
+  icon="-"
+  ansiline 0 0 "$icon"
+  while : ; do
+    spinloop 1000
+    case "$icon" in
+      '-') icon='\';; '\') icon='|';; '|') icon='/';; '/') icon='-';;
+    esac
+    ansiline 1 -1 "$icon"
+  done
+}
+progressHandler() {
+    [ -z "${-%%*x*}" ] && set +x  # Disable -x debug if set for this process
+    type=$1
+    completiontext=$2  # Custom end text (when the process is complete)
+    
+    # Check if there is a file redirect for stdout (where we echo progress to)
+    # If so, then adding progress to the file will cause large volumes of tty commands
+    # to be written - best to have no progress so ignore
+    [ ! -t 1 ] && return
+    trapcmd="exit;"
+    [ -n "$completiontext" ] && trapcmd="/bin/echo \"\047[1A\047[30D\047[2K$completiontext\"; $trapcmd"
+    trap "$trapcmd" HUP
+    case "$type" in
+      "network") progressNetwork;;
+      *)         progressSpinner;;
+    esac
+}
+
+
 runInBackgroundWithTimeoutAndLog()
 {
   command="$1"
@@ -112,23 +560,48 @@ runInBackgroundWithTimeoutAndLog()
 
 printSoftError()
 {
+  [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
   printColors "${NC}${RED}${BOLD}***ERROR: ${NC}${RED}${1}${NC}" >&2
+  [ -n "$xtrc" ] && set -x
 }
 
 printError()
 {
-  printSoftError "${1}"
+  [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
+  printColors "${NC}${RED}${BOLD}***ERROR: ${NC}${RED}${1}${NC}" >&2
+  [ -n "$xtrc" ] && set -x
+  mutexFree "zopen" # prevent lock from lingering around after an error
+  cleanupFunction
   exit 4
 }
 
 printWarning()
 {
+  [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
   printColors "${NC}${YELLOW}${BOLD}***WARNING: ${NC}${YELLOW}${1}${NC}" >&2
+  [ -n "$xtrc" ] && set -x
+  return 0;
 }
 
 printInfo()
 {
+  [ -z "${-%%*x*}" ] && set +x && xtrc="-x" || xtrc=""
   printColors "$1" >&2
+  [ -n "$xtrc" ] && set -x
+  return 0;
+}
+
+# Used to input sensitive data - turns off echo to the screen for the input
+getInputHidden()
+{
+  # Register trap-handler to try and ensure that we restore the screen to display 
+  # chars in the event the script is terminated early (eg. user hits CTRL-C instead of 
+  # answering the masked question)
+  addCleanupTrapCmd "stty echo"
+  stty -echo
+  read zopen_input
+  echo $zopen_input
+  stty echo
 }
 
 getInput()
@@ -158,8 +631,11 @@ printElapsedTime()
 
 processConfig()
 {
-  if [ -f "$HOME/.zopen-config" ]; then
-    . "$HOME/.zopen-config"
+  export ZOPEN_QUICK_LOAD=1
+  if [ -z "$ZOPEN_ROOTFS" ]; then
+    if [ -f "$HOME/.zopen-config" ]; then
+      . "$HOME/.zopen-config"
+    fi
   fi
 }
 
@@ -231,7 +707,7 @@ validateVersion()
   operator=$2
   requestedVersion=$3
   dependency=$4
-  if [ ! -z "$operator" ] && [ -z "$version" ]; then
+  if [ -n "$operator" ] && [ -z "$version" ]; then
     printVerbose "$operator ${requestedVersion} requsted, but no version file found in $versionPath." 
     return 1
   elif [ ! -z "$operator" ] && ! compareVersions "${version}" "${requestedVersion}"; then
@@ -241,6 +717,154 @@ validateVersion()
   return 0
 }
 
+deleteDuplicateEntries() 
+{
+  value=$1
+  delim=$2
+  echo "$value$delim" | awk -v RS="$delim" '!($0 in a) {a[$0]; printf("%s%s", col, $0); col=RS; }' | sed "s/${delim}$//"
+}
+# reworked version of above to strip blank elements between delims
+deleteDuplicateEntriesRedux() 
+{
+  value=$1
+  delim=$2
+  echo "$value" | awk -v RS="$delim" -v ORS="$delim" ' {gsub("^[ ]+|[ ]$", "", $0); if (NF>0 && !a[$0]++) {print } }' | sed "s/${delim}$//"
+}
+
+# Logging Types
+LOG_E="ERROR"    # If there was a failure and a command failed
+LOG_W="WARNING"  # If an error occurred but there was a workaround/fallback
+LOG_I="INFO"     # General information
+LOG_A="AUDIT"    # Security-type log for admin activities
+
+# Logging Categories - more than one possible for a log entry
+CAT_CONFIG="C"    # Configuration change
+CAT_FILE="F"      # File handling (eg. downloading)
+CAT_INSTALL="I"   # Install processing
+CAT_NETWORK="N"   # Network processing
+CAT_PKG="P"       # Package handling
+CAT_QUERY="Q"     # Query processing
+CAT_REMOVE="R"    # Removal handling
+CAT_SYS="S"       # Related to the underlying native z/OS system
+CAT_ZOPEN="Z"     # Related to the zopen system itself
+
+syslog() {
+  fd=$1
+  type=$2
+  categories=$3
+  module=$4
+  location=$5
+  msg=$6
+  if [ ! -e "$fd" ]; then
+    mkdir -p "$(dirname "$fd")"
+    touch "$fd"
+  fi
+  echo $(date +"%F %T") $(id | cut -d' ' -f1)::$module:$type:$categories:$location:$msg >> $fd
+}
+
+parseResponseHeaders(){
+  responseHeaders=$(echo "$httpresponse" | awk '/^[ ]*[a-zA-Z0-9]/ {print} ')
+}
+parseResponseBody(){
+  responseBody=$(echo "$httpresponse" | awk '!/^[ ]*[a-zA-Z0-9]/ {print} ')
+}
+parseHttpRc(){
+  if [ -z "$responseHeaders" ]; then
+    parseResponseHeaders
+  fi
+  responseRc=$(echo "$responseHeaders" | head -n 1 | cut -d' ' -f 2)
+}
+
+httprequest() {
+  url="$1"
+  expectedRc="$2" # Space separated list of http rcs that are handled by caller
+  printVerbose "Requesting from url: ${url} "
+  uricmd="curl --include $OAUTH_TOKEN_OPTION $OAUTH_TOKEN -s $url"
+  if ! httpresponse=$(curl --include "$OAUTH_TOKEN_OPTION" "$OAUTH_TOKEN" -s "$url"); then
+    printError "Unable to download from url: '$url'. Resolve reported issue and retry"
+  fi
+  parseResponseHeaders
+  parseResponseBody
+  parseHttpRc
+  case "$expectedRc" in
+    *$responseRc*) printVerbose "Request completed as expected ($responseRc)";;
+    *) printVerbose "Request completed with response: $responseRc";
+       case "$responseRc" in
+         '200') printVerbose "Request completed successfully to URL: $url";;
+         '401') printError "Your ZOPEN_GIT_OAUTH_TOKEN is invalid. Please validate that it is correct and re-run.";;
+         '403') if echo "$httpresponse" | grep -q "API rate limit exceeded for" 2>/dev/null; then
+                  printError "API rate limit exceeded for github.\n1. Generate a token (https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token).\n2. Set ZOPEN_GIT_OAUTH_TOKEN and rerun"
+                else
+                  printError "Unable to access URL: $url"
+                fi
+                return 8;;
+         '404') printError "URL $url not found";;
+         * ) printError "Bad response code $responseRc when accessing URL: $url";;
+       esac;;
+  esac
+  return $responseRc
+}
+
+parseJsonRepos(){
+   [ -z "$jsonResponse" ] && echo "" && return
+   echo "$jsonResponse" | awk -F'"' ' /full_name/ { print $4 }'
+}
+
+downloadJSONCache() {
+  if [ -z "$JSON_CACHE" ]; then
+    JSON_CACHE="$ZOPEN_ROOTFS/var/cache/zopen/zopen_releases.json"
+    JSON_TIMESTAMP="$ZOPEN_ROOTFS/var/cache/zopen/zopen_releases.timestamp"
+    JSON_TIMESTAMP_CURRENT="$ZOPEN_ROOTFS/var/cache/zopen/zopen_releases.timestamp.current"
+    if ! curl -L -s -I "$ZOPEN_JSON_CACHE_URL" -o "$JSON_TIMESTAMP_CURRENT"; then
+      printError "Failed to obtain json cache timestamp from $ZOPEN_JSON_CACHE_URL"
+    fi
+    chtag -tc 819 "$JSON_TIMESTAMP_CURRENT"
+
+    if [ -f "$JSON_CACHE" ] && [ -f "$JSON_TIMESTAMP" ] && [ "$(grep 'Last-Modified' "$JSON_TIMESTAMP_CURRENT")" = "$(grep 'Last-Modified' "$JSON_TIMESTAMP")" ]; then
+      return;
+    fi
+
+    mv "$JSON_TIMESTAMP_CURRENT" "$JSON_TIMESTAMP"
+    if ! curl -L -s -o "$JSON_CACHE" "$ZOPEN_JSON_CACHE_URL" ; then
+      printError "Failed to obtain json cache from $ZOPEN_JSON_CACHE_URL"
+    fi
+    chtag -tc 819 "$JSON_CACHE"
+  fi
+
+  if [ ! -f "$JSON_CACHE" ]; then
+    printError "Could not download json cache from $ZOPEN_JSON_CACHE_URL"
+  fi
+}
+
+getReposFromGithub(){
+  downloadJSONCache
+  repo_results="$(cat "$JSON_CACHE" | jq -r '.release_data | keys[]')"
+}
+
+getAllReleasesFromGithub(){
+  downloadJSONCache
+  repo="$1"
+  releases="$(jq -e -r '.release_data."'$repo'"' "$JSON_CACHE")"
+  if [ $? -ne 0 ]; then
+    printError "Could not get all releases for $repo"
+  fi
+}
+
+getContentsFromGithub(){
+  url="$1"
+  printVerbose "Requesting from url: ${url} "
+  if ! repo_results=$(curl --include "$OAUTH_TOKEN_OPTION" "$OAUTH_TOKEN" -s "$url"); then
+    printError "Unable to download from url: '$url'. Resolve reported issue and retry" 
+  fi
+  if echo "$repo_results" | grep -q "API rate limit exceeded for" 2>/dev/null; then
+    printError "API rate limit exceeded for github.\n1. Generate a token (https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token).\n2. Set ZOPEN_GIT_OAUTH_TOKEN and rerun"
+  fi
+  if echo $repo_results | grep -q "Bad credentials" 2>/dev/null; then
+    printError "Your ZOPEN_GIT_OAUTH_TOKEN is invalid. Please validate that it is correct and re-run."
+  fi
+  echo "$repo_results";
+}
+
 initDefaultEnvironment()
 {
   export ZOPEN_OLD_PATH=$PATH # Preserve PATH in case scripts need to access it
diff --git a/bin/lib/zopen-alt b/bin/lib/zopen-alt
new file mode 100755
index 000000000..2fac077dd
--- /dev/null
+++ b/bin/lib/zopen-alt
@@ -0,0 +1,159 @@
+#!/bin/sh
+# "Alternatives" utility for z/OS Open Tools - https://github.com/ZOSOpenTools
+
+export utildir="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
+
+. "${utildir}/common.inc"
+
+printSyntax() 
+{
+  args=$*
+  echo "zopen alt is a utility for z/OS Open Tools to switch package versions for currently installed packages" >&2
+  echo "Syntax: zopen-alt [<option>]* [<package]" >&2
+  echo "  where <option> may be one or more of:" >&2
+  echo "  -s | --set: set version" >&2
+  echo "  -v | --v | -verbose | --verbose: run in verbose mode." >&2
+  echo "  -h | --h | -help | --help | -? | -syntax: print this information" >&2
+  echo "  -d: specify default option for an alternative" >&2
+  echo " and <package> is a package name." >&2
+}
+
+setAlt(){
+  i=$1
+  needle=$2
+  printVerbose "Setting alternative"
+    valid=false
+    while ! $valid; do
+      if [ -n "$defaultoption" ]; then
+        selection="$defaultoption"
+        defaultoption="" # Only try it once
+      else 
+        echo "Enter alternative version to use (1-$i): "
+        selection=$(getInput)
+      fi
+      if [[ ! -z "$(echo $selection | sed -e 's/[0-9]*//')" ]]; then
+        echo "Invalid input, must be a number between 1 and $i"
+      elif [ "$selection" -ge 1 ] && [ "$selection" -le "$i" ]; then
+        valid=true
+      fi
+    done
+    if [ ! $selection -eq $current ]; then
+      newver="$(echo $found | awk -v selection=$selection '
+        BEGIN {count=0}
+              {count = count + 1; if (count=selection) { print $(selection)} }
+      ')"
+      printInfo "Setting alternative: $selection: $newver"
+      [ -d $ZOPEN_PKGINSTALL/$newver ] || printError "Mismatch found, no version directory at $newver" 
+      [ -n "$needle" ] || printError "$ZOPEN_PKGINSTALL/$needle not found"
+      if [ -e $ZOPEN_PKGINSTALL/$needle ]; then
+        printVerbose "Removing master link"
+        rm -rf $ZOPEN_PKGINSTALL/$needle
+      fi
+
+      mergeIntoSystem "$needle" "$ZOPEN_PKGINSTALL/$newver" "$ZOPEN_ROOTFS" 
+      printVerbose "New version merged; checking for orphaned files from previous version"
+      # This will remove any old symlinks or dirs that might have changed in an up/downgrade
+      # as the merge process overwrites existing files to point to different version. If there was
+      # no other version, then $deref will be empty so nothing to uninstall
+      if [ -n "$deref" ]; then
+        unsymlinkFromSystem "$needle" "$ZOPEN_ROOTFS" "${ZOPEN_PKGINSTALL}/$deref/.links"
+      else
+        printVerbose "No previous version found (no .links) - no unlinking performed"
+      fi 
+      
+      misrc=$?
+      printVerbose "The merge complete with: $misrc"
+      printVerbose "Generating main link from $needle to version: $newver"
+      if ! ln -sf $newver $ZOPEN_PKGINSTALL/$needle; then
+        printError "Could not create symbolic link name"
+      fi
+      touch "${ZOPEN_PKGINSTALL}/${needle}/.active"
+      version="unknown"
+      if [ -e "${ZOPEN_PKGINSTALL}/${needle}/.releaseinfo" ]; then
+        version=$(cat "${ZOPEN_PKGINSTALL}/${needle}/.releaseinfo")
+      fi
+      syslog $ZOPEN_LOG_PATH/audit.log $LOG_A "$CAT_PACKAGE" "ALT" "setAlt" "Set '${needle}' to version:$version;"
+    else
+      printInfo "Selection is already current version."
+      exit 0
+    fi
+}
+
+listAlts(){
+  sett=$1
+  needle=$2
+
+  found=$(zosfind $ZOPEN_PKGINSTALL -type d -o -type l| grep "$needle-[^/]*$" | sed -e "s#$ZOPEN_PKGINSTALL/##")
+  if [[ -z $found ]]; then
+    printInfo "No currently available version of package '${needle}'"
+    exit 4
+  fi
+  if [ -e $ZOPEN_PKGINSTALL/$needle ]; then
+    deref=$(ls -l $ZOPEN_PKGINSTALL/$needle | awk '{ print $(NF) }')
+    printVerbose "Current version: ${deref#$ZOPEN_PKGINSTALL/}"
+  fi
+
+  i=0
+  current=0
+# just the below would be simpler, but creates a subshell so can't get the number of entries outside!  
+#  echo "$found" | xargs | tr ' ' '\n' | while read repo; do
+  TMP_FIFO_PIPE="$HOME/altselect.pipe"
+  [[ ! -p $TMP_FIFO_PIPE ]] || rm -f $TMP_FIFO_PIPE
+  mkfifo $TMP_FIFO_PIPE
+  echo "$found" | xargs | tr ' ' '\n' >> $TMP_FIFO_PIPE &
+  while read repo; do
+    printVerbose "Parsing repo: '$repo' as '${repo#$ZOPEN_PKGINSTALL/}'"
+    i=$(expr $i + 1)
+    if [[ "${deref#$ZOPEN_PKGINSTALL/}" = "${repo#$ZOPEN_PKGINSTALL/}" ]]; then
+      current=$i
+      printInfo "${NC}${GREEN}$i: ${repo#$ZOPEN_PKGINSTALL/}  <-  current${NC}"
+    else
+      printInfo "$i: ${repo#$ZOPEN_PKGINSTALL/}"
+    fi
+  done < $TMP_FIFO_PIPE
+  [[ ! -p $TMP_FIFO_PIPE ]] || rm -rf $TMP_FIFO_PIPE
+
+  if $sett; then
+    mutexReq "zopen" "zopen"
+    setAlt "$i" "$needle" "$deref"
+    unset $sett
+    mutexFree "zopen"
+    listAlts false "$needle"
+  fi
+  exit 0
+}
+
+
+# Main code start here
+args=$*
+verbose=false
+sett=false
+defaultoption=""
+if [[ $# -eq 0 ]]; then
+  printError "No option provided for query"
+fi
+while [[ $# -gt 0 ]]; do
+  printVerbose "Parsing option: $1"
+  case "$1" in
+    "-s" | "--set")
+      sett=true
+      ;;
+    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+      printSyntax "${args}"
+      exit 4
+      ;;
+    "-v" | "--v" | "-verbose" | "--verbose")
+      verbose=true
+      ;;
+    "-d") defaultoption="$2"
+          shift
+          ;;
+    *)
+      packageList="$packageList $1";
+      ;;
+  esac
+  shift;
+done
+
+[[ -z "$packageList" ]] || listAlts $sett $packageList
+printError "No action verb specified"
diff --git a/bin/lib/zopen-build b/bin/lib/zopen-build
index 724624877..7db1f90c1 100755
--- a/bin/lib/zopen-build
+++ b/bin/lib/zopen-build
@@ -239,8 +239,8 @@ processOptions()
   generateSymLink=true
   forcePatchApply=false
   depsPath="$HOME/zopen/prod|$HOME/zopen/boot|/usr/bin/zopen/"
-  if [ ! -z "$ZOPEN_SEARCH_PATH" ]; then
-    depsPath="$ZOPEN_SEARCH_PATH/prod|$ZOPEN_SEARCH_PATH/boot|$depsPath"
+  if [ ! -z "$ZOPEN_PKGINSTALL" ]; then
+    depsPath="$ZOPEN_PKGINSTALL|$depsPath"
   fi
   forceUpgradeDeps=false
   while [[ $# -gt 0 ]]; do
@@ -506,7 +506,7 @@ setDepsEnv()
       fi
       # Use the first path specified in the dependency search list
       path=$(echo ${depsPath} | tr '|' '\n' | head -1)
-      if ! runAndLog "PATH=\"$curlpath:$PATH\" zopen install --install-or-upgrade -r $dep -d $path -v"; then
+      if ! runAndLog "PATH=\"$curlpath:$PATH\" $utildir/zopen-download --install-or-upgrade -r $dep -v -y"; then
         printError "zopen install command failed"
       fi
       depdir="$path/${dep}"
@@ -1177,7 +1177,8 @@ zz
   if command -V "${ZOPEN_APPEND_TO_ENV_CODE}" >/dev/null 2>&1; then
     printVerbose "Appending additional environment variables..."
     append_to_env="$(${ZOPEN_APPEND_TO_ENV_CODE})"
-    echo "$append_to_env" >> "${ZOPEN_INSTALL_DIR}/.env"
+    echo "$append_to_env" > "${ZOPEN_INSTALL_DIR}/.appenv"
+    echo ". ./.appenv" >> "${ZOPEN_INSTALL_DIR}/.env"
   fi
 
   cat <<zz >>"${ZOPEN_INSTALL_DIR}/.env"
@@ -1268,7 +1269,7 @@ ZZ
   echo "$ZOPEN_RUNTIME_DEPS" | xargs | tr ' ' '\n' | sort | while read dep; do
     # Use the first path specified in the dependency search list to install to
     path=$(echo ${depsPath} | tr '|' '\n' | head -1)
-    if ! runAndLog "PATH=\"$curlpath:$PATH\" zopen install $dep -v -d $path --nodeps"; then
+    if ! runAndLog "PATH=\"$curlpath:$PATH\" $utildir/zopen-download $dep -v --no-deps -y"; then
       printError "Failed to install dependencies"
     fi
     cat <<ZZ >> "${ZOPEN_INSTALL_DIR}/.depsenv"
@@ -1423,7 +1424,7 @@ resolveCommands()
     fi
   fi
   if [ "${ZOPEN_INSTALL_DIR}x" = "x" ]; then
-    export ZOPEN_INSTALL_DIR="${HOME}/zopen/prod/${ZOPEN_NAME}"
+    export ZOPEN_INSTALL_DIR="$ZOPEN_PKGINSTALL/${ZOPEN_NAME}"
   fi
   if [ "${ZOPEN_LOG_DIR}x" = "x" ]; then
     export ZOPEN_LOG_DIR="${ZOPEN_ROOT}/log"
diff --git a/bin/lib/zopen-clean b/bin/lib/zopen-clean
new file mode 100755
index 000000000..b60f2ac64
--- /dev/null
+++ b/bin/lib/zopen-clean
@@ -0,0 +1,156 @@
+#!/bin/sh
+# Cleanup utility for z/OS Open Tools - https://github.com/ZOSOpenTools
+
+export utildir="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
+
+. "${utildir}/common.inc"
+
+printSyntax() 
+{
+  args=$*
+  echo "zopen clean is a utility for z/OS Open Tools to switch package versions for currently installed packages" >&2
+  echo "Syntax: zopen-clean [<option>]* [<package]" >&2
+  echo "  where <option> may be one or more of:" >&2
+  echo "      -u : --unused: removes unused package versions" >&2
+  echo "      -d : --dangling: removes dangling symlinks" >&2
+  echo "      -c : --cache: cleans package cache" >&2
+  echo "      -a : --all:  equivalent to -u -d -c" 
+  echo "  -v: run in verbose mode." >&2
+  echo "TODO and <package> is a package name." >&2
+}
+
+
+cleanUnused(){
+  needle=$1
+  found=$(zosfind $ZOPEN_PKGINSTALL -name "*/${needle}-*" -prune -type d  | grep "/${needle}-[^/]*")
+  if [[ -z $found ]]; then
+    printInfo "No currently installed version of package '${needle}'"
+    return
+  fi
+  if [ -e "$ZOPEN_PKGINSTALL/$needle" ]; then
+    deref=$(ls -l $ZOPEN_PKGINSTALL/$needle | awk '{ print $(NF) }')
+    printVerbose "Current version: ${deref#$ZOPEN_PKGINSTALL/}"
+  else
+    printInfo "No current version of $needle installed. Removing all unused versions"
+  fi
+
+  i=0
+  current=0
+# the below would be simpler, but creates a subshell so can't get the number of entries outside!  
+#  echo "$found" | xargs | tr ' ' '\n' | while read repo; do
+  TMP_FIFO_PIPE="$HOME/altselect.pipe"
+  [[ ! -p $TMP_FIFO_PIPE ]] || rm -f $TMP_FIFO_PIPE
+  mkfifo $TMP_FIFO_PIPE
+  echo "$found" | xargs | tr ' ' '\n'>> $TMP_FIFO_PIPE &
+  while read repo; do
+    printVerbose "Parsing repo: '$repo' as '${repo#$ZOPEN_PKGINSTALL/}'"
+    if [[ "${repo}" = "${repo#$ZOPEN_PKGINSTALL/}" ]]; then
+      printVerbose "Working around possible bug in FIFO that converts initial char to alert/bell 0x07/'\a'"
+      if ! $(type od); then
+        printVerbose "Displaying erroneous string"
+        out=$(echo "${repo}" | od -cx)
+        printVerbose "String details:\n '$out'"
+      fi
+      repo="/$(echo $repo | cut -b 2-)"
+      printVerbose "Repo:='$repo'"
+      syslog $ZOPEN_LOG_PATH/audit.log $LOG_W "$CAT_FILE,$CAT_SYS" "CLEAN" "cleanUnused" "FIFO character issue while reading from $TMP_FIFO_PIPE. Workaround applied"
+    fi
+    i=$(expr $i + 1)
+    if [[ "${deref#$ZOPEN_PKGINSTALL/}" = "${repo#$ZOPEN_PKGINSTALL/}" ]]; then
+      current=$i
+      printInfo "${NC}${GREEN}$i: ${repo#$ZOPEN_PKGINSTALL/}  <-  current${NC}"
+    else
+      rm -rf "$repo" >/dev/null 2>&1 
+      printInfo "$i: ${repo#$ZOPEN_PKGINSTALL/} <- Removed"
+      syslog $ZOPEN_LOG_PATH/audit.log $LOG_A "$CAT_FILE,$CAT_PACKAGE,$CAT_REMOVE" "CLEAN" "cleanUnused" "Removed unused package at ${repo#$ZOPEN_PKGINSTALL/} "
+    fi
+  done < $TMP_FIFO_PIPE
+  [[ ! -p $TMP_FIFO_PIPE ]] || rm -f $TMP_FIFO_PIPE
+}
+cleanDangling(){
+  printVerbose "Removing dangling symlinks from the file structure"
+  if [ "$ZOPEN_ROOTFS" = "/." ]; then
+    printWarning "With zopen's root set as '/', traversal to find dangling symlinks"
+    printWarning "will occur on ALL mounted file systems, ALL sub-directories and will"
+    printWarning "attempt to remove any dangling symlinks it finds, regardless of how they"
+    printWarning "were created or which package/product/install mechanism was used and if "
+    printWarning "the user has permission to do so (errors will be reported if not)."
+    printWarning "Are you absolutely sure you want to run this option (y/N)?"
+    read absolutely < /dev/tty
+    if [ -n "$absolutely" ] && [ "y" = "${absolutely}" ]; then
+      printInfo "- Checking for any dangling symlinks across system"
+    else
+      exit 4
+    fi
+  fi
+  progressHandler "spinner" "- Dangling link removal complete" &
+  ph=$!
+  killph="kill -HUP $ph"
+  addCleanupTrapCmd "$killph"
+  flecnt=0
+  zosfind $ZOPEN_ROOTFS -type l -exec test ! -e {} \; -print | while read sl; do
+    printVerbose "Removing symlink '$sl'"
+    rm -f $sl
+    flecnt=$(expr $flecnt + 1)
+  done
+  $killph 2>/dev/null  # if the timer is not running, the kill will fail
+  syslog $ZOPEN_LOG_PATH/audit.log $LOG_A "$CAT_FILE" "CLEAN" "cleanDangling" "zopen system scanned for dangling symlinks; $flecnt link(s) removed"
+}
+cleanCache(){
+  printVerbose "Cleaning $ZOPEN_ROOTFS/var/cache/zopen"
+  rm -rf $ZOPEN_ROOTFS/var/cache/zopen/*
+  syslog $ZOPEN_LOG_PATH/audit.log $LOG_A "$CAT_FILE" "CLEAN" "cleanCache" "Main cache in $ZOPEN_ROOTFS/var/cache/zopen cleared"
+}
+
+# Main code start here
+args=$*
+verbose=false
+unused=false
+dangling=false
+cache=false
+package=""
+
+if [[ $# -eq 0 ]]; then
+  printError "No option provided for cleaning"
+fi
+while [[ $# -gt 0 ]]; do
+  printVerbose "Parsing option: $1"
+  case "$1" in
+      "-u" | "--unused")
+      unused=true
+      ;;
+      "-d" | "--dangling")
+      dangling=true
+      ;;
+      "-c" | "--cache")
+      cache=true
+      ;;
+      "-a" | "--all")
+      unsed=true
+      dangling=true
+      cache=true
+      ;;
+    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+      printSyntax "${args}"
+      exit 4
+      ;;
+    "-v" | "--v" | "-verbose" | "--verbose")
+      verbose=true
+      ;;
+    *)
+      package="$1";
+      ;;
+  esac
+  shift;
+done
+
+if $unused; then 
+  cleanUnused $package
+fi
+if $dangling; then 
+  cleanDangling
+fi
+if $cache; then
+  cleanCache
+fi
+
diff --git a/bin/lib/zopen-download b/bin/lib/zopen-download
new file mode 100755
index 000000000..c60557f1d
--- /dev/null
+++ b/bin/lib/zopen-download
@@ -0,0 +1,509 @@
+#!/bin/sh
+# Install utility for z/OS Open Tools - https://github.com/ZOSOpenTools
+
+export utildir="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
+
+. "${utildir}/common.inc"
+
+VERSION=1.0.0
+printVersion(){
+  ver="$VERSION"
+  echo "$(basename "$0") (z/OS Tools)  ${ver}" 
+}
+printSyntax() 
+{
+  args=$*
+  echo "zopen download is a utility to download/install a z/OS Open Tools package."
+  echo "Syntax: zopen download [<option>]* <package, ...>" >&2
+  echo "  where <option> may be one or more of:" >&2
+  echo "  -u|--update|--upgrade: updates installed z/OS Open Tools packages."  >&2
+  echo "  --install-or-upgrade: installs the package if not installed, or upgrades the package if installed."  >&2
+  echo "  --reinstall: reinstall already installed z/OS Open Tools packages."  >&2
+  echo "  --nosymlink: do not integrate into filesystem through symlink redirection. " >&2
+  echo "  --release-line <stable|dev>: the release line to build off of." >&2
+  echo "  --no-deps: do not install dependencies."  >&2
+  echo "  --cache-only: do not install dependencies."  >&2
+  echo "  --no-set-active: do not change the pinned version"  >&2
+  echo "  --skip-upgrade: do not upgrade."  >&2
+  echo "  --yes|-y: automatically answer yes to prompts."  >&2
+  echo "  --select: select a version to install."  >&2
+  echo "  -v: run in verbose mode" >&2
+  echo "  --download-only: download package to current directory" >&2
+  echo "  --local-install: download and unpackage to current directory" >&2
+  echo "  --all: download/install all z/OS Open Tools packages" >&2
+  echo "  and <package> is a list of one or more projects to install" >&2
+}
+
+installDependencies()
+(
+  name=$1
+  printVerbose "List of dependencies to install: $dependencies"
+  skipupgrade_lcl=$skipupgrade
+  skipupgrade=true
+  echo "$dependencies" | xargs | tr ' ' '\n' | sort | while read dep; do
+    printVerbose "Removing '$dep' from dependency queue '$dependencies'"
+    dependencies=$(echo "$dependencies" | sed -e "s/$dep//" | tr -s ' ')
+    handlePackageInstall "$dep"
+  done
+  skipupgrade=$skipupgrade_lcl
+)
+
+handlePackageInstall(){
+
+  fullname="$1"
+  printVerbose "Name to install: $fullname, parsing any version ('=') or tag ('%') has been specified"
+  name=$(echo "$fullname" | sed -e 's#[=%].*##')
+  repo="${name}"
+  versioned=$(echo "$fullname" | cut -s -d '=' -f 2)
+  tagged=$(echo "$fullname" | cut -s -d '%' -f 2)
+  printVerbose "Name:$name;version:$versioned;tag:$tagged;repo:$repo"
+  printHeader "Installing package: $name"
+
+  getAllReleasesFromGithub "${repo}"
+
+  originalFileVersion=""
+  printVerbose "Checking for meta file at: ${ZOPEN_PKGINSTALL}/${name}/.releaseinfo"
+  if [ -e "${ZOPEN_PKGINSTALL}/${name}/.releaseinfo" ]; then
+    originalFileVersion=$(cat "${ZOPEN_PKGINSTALL}/${name}/.releaseinfo")
+    printVerbose "Found originalFileVersion=$originalFileVersion (port is already installed)"
+  elif [ -e "${ZOPEN_PKGINSTALL}/${name}/.version" ]; then
+    originalFileVersion=$(cat "${ZOPEN_PKGINSTALL}/${name}/.version")
+    printVerbose "Found originalFileVersion=$originalFileVersion (port is already installed)"
+  else
+    printVerbose "Could not detect existing installation at ${ZOPEN_PKGINSTALL}/${name}"
+  fi
+
+  downloadURL=""
+  if [ ! -z "$releaseLine" ]; then  
+    asset="$(/bin/printf "%s" "$releases" | jq -e -r '. | map(select(.tag_name | startswith("'$releaseLine'")))[0].assets[0]')"
+    if [ $? -ne 0 ]; then
+      printError "Could not find release-line $releaseLine for repo $repo"
+    fi
+  elif [ ! "x" = "x$versioned" ]; then
+    printVerbose "Specific version $versioned requested - checking existence and URL"
+    requestedMajor=$(echo "$versioned" | awk -F'.' '{print $1}')
+    requestedMinor=$(echo "$versioned" | awk -F'.' '{print $2}')
+    requestedPatch=$(echo "$versioned" | awk -F'.' '{print $3}')
+    requestedSubrelease=$(echo "$versioned" | awk -F'.' '{print $4}')
+    requestedVersion="${requestedMajor}\\\.${requestedMinor}\\\.${requestedPatch}\\\.${requestedSubrelease}"
+    printVerbose "Finding URL for latest release matching version prefix: requestedVersion: $requestedVersion"
+    asset=$(/bin/printf "%s" "$releases" | jq -e -r '. | map(select(.assets[].name | test("'$requestedVersion'")))[0].assets[0]')
+  elif [ ! "x" = "x$tagged" ]; then
+    asset=$(/bin/printf "%s" "$releases" | jq -e -r '.[] | select(.tag_name == "'$tagged'").assets[0]')
+    if [ $? -ne 0 ]; then
+      printError "Could not find tag $tagged for repo $repo"
+    fi
+  elif $selectVersion; then
+    # Explicitly allow the user to select a release to install; useful if there are broken installs
+    # as a known good release can be found, selected and pinned!
+    printVerbose "List individual releases and allow selection"
+    i=$(/bin/printf "%s" "$releases" | jq -r 'length - 1')
+    printInfo "Versions available for install:"
+    /bin/printf "%s" "$releases" | jq -e -r 'to_entries | map("\(.key): \(.value.tag_name) - \(.value.assets[0].name) - size: \(.value.assets[0].expanded_size/ (1024 * 1024))mb")[]'
+
+    printVerbose "Getting user selection"
+    valid=false
+    while ! $valid; do
+      echo "Enter version to install (0-$i): "
+      read selection < /dev/tty
+      if [[ ! -z $(echo "$selection" | sed -e 's/[0-9]*//') ]]; then
+        echo "Invalid input, must be a number between 0 and $i"
+      elif [ "$selection" -ge 0 ] && [ "$selection" -le "$i" ]; then
+        valid=true
+      fi
+    done
+    asset="$(/bin/printf "%s" "$releases" | jq -e -r ".[$selection].assets[0]")"
+  else
+    asset="$(/bin/printf "%s" "$releases" | jq -e -r ".[0].assets[0]")"
+    printVerbose "No explicit version/tag, using latest"
+  fi
+
+  if [ "x" = "x$asset" ]; then
+    printError "Unable to determine download asset for ${name}"
+  fi
+
+  downloadURL=$(/bin/printf "%s" "$asset" | jq -e -r '.url')
+  size=$(/bin/printf "%s" "$asset" | jq -e -r '.expanded_size')
+
+  if [ "x" = "x$downloadURL" ]; then
+    printError "Unable to determine download location for ${name}"
+  fi
+  downloadFile=$(basename "$downloadURL")
+  downloadFileVer=$(echo "$downloadFile" |sed -E 's/.*-(.*)\.zos\.pax\.Z/\1/')
+  printVerbose "Downloading port from URL: $downloadURL to file: $downloadFile (ver=$downloadFileVer)"
+
+  printVerbose "Install=${downloadFileVer};Original=${originalFileVersion};${upgradeInstalled};${installOrUpgrade};${reinstall}"
+  if [ "${downloadFileVer}" = "${originalFileVersion}" ]; then
+    if ! $reinstall; then
+      printInfo "${NC}${GREEN}Package ${name} is already installed at the requested version: ${downloadFileVer}${NC}"
+      return;
+    fi
+    printInfo "- Reinstalling version '$downloadFileVer' of ${name}..."
+  fi
+
+  printVerbose "Checking if package is not installed but scheduled for upgrade"
+  if [ "x" = "x$originalFileVersion" ]; then
+    printVerbose "No previous version found"
+    if $installOrUpgrade; then
+      printVerbose "Package ${name} was not installed so not upgrading but installing"
+    elif $upgradeInstalled; then
+      printError "Package ${name} can not be upgraded as it is not installed!"
+      continue;
+    fi
+    unInstallOldVersion=false
+    printInfo "- Installing ${name}..."
+  elif $skipupgrade; then
+    printInfo "Package ${name} has a newer release '${downloadFileVer}' but explicitly skipping"
+    continue;
+  elif ! $setactive; then
+    printVerbose "Current version '${originalFileVersion}' will remain active"
+    unInstallOldVersion=false
+  else
+    printVerbose "Previous version '${originalFileVersion}' installed"
+    if [ -e "${ZOPEN_PKGINSTALL}/${name}/.pinned" ]; then
+      printWarning "- Version '${originalFileVersion}' has been pinned; upgrade to '${downloadFileVer}' skipped"
+      syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_PACKAGE,$CAT_INSTALL" "DOWNLOAD" "handlePackageInstall" "Attempt to change pinned package '${name}' skipped"
+      continue;
+    else
+      printInfo "- Replacing ${name} version '${originalFileVersion}' with '${downloadFileVer}'"
+      unInstallOldVersion=true
+      currentversiondir=$(cd "$ZOPEN_PKGINSTALL/$name" && pwd -P)
+      currentlinkfile="$currentversiondir/.links"
+    fi
+  fi
+
+  printVerbose "Checking cache for already downloaded package [file name comparison]"
+  pax=$downloadFile
+  if [ -f "$pax" ]; then
+    printInfo "- Found existing file '${pax}' in download cache."
+  else
+    printInfo "- Downloading $pax to cache..."
+    if ! $verbose; then
+      redirectToDevNull="2>/dev/null"
+    fi
+
+    progressHandler "network" "- Downloaded $pax to cache" &
+    ph=$!
+    killph="kill -HUP $ph"
+    addCleanupTrapCmd "$killph"
+    if ! runAndLog "curl -L '${downloadURL}' -O ${redirectToDevNull}"; then
+      printError "Could not download from ${downloadURL}. Correct any errors and potentially retry"
+      continue;
+    fi
+    $killph 2>/dev/null  # if the timer is not running, the kill will fail
+    syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_NETWORK,$CAT_PACKAGE,$CAT_FILE" "DOWNLOAD" "handlePackageInstall" "Downloaded remote file '$pax' to cache"
+  fi
+  if [ ! -f "${pax}" ]; then
+    printError "${pax} was not found after downloaded!?!"
+  fi
+
+  if ! $downloadOnly & ! $cacheOnly; then
+    installdirname="${pax%.pax.Z}" # Use full pax name as default
+
+    printInfo "- Processing $pax..."
+    baseinstalldir="."
+    paxredirect=""
+    if ! $localInstall; then
+      baseinstalldir=$ZOPEN_PKGINSTALL
+      paxredirect="-s %[^/]*/%$ZOPEN_PKGINSTALL/$installdirname/%"
+      printVerbose "Non-local install, extracting with '$paxredirect'"
+    else
+      printInfo "- Local install specified, expanding pax to ."
+    fi
+  
+    printVerbose "Check for existing directory for version '$installdirname'"
+    if [ -d "$baseinstalldir/$installdirname" ]; then 
+      printInfo "- Clearing existing directory and contents"
+      rm -rf "$baseinstalldir/$installdirname"
+    fi
+
+    megabytes=$(echo "scale=2; $size / (1024 * 1024)" | bc)
+    printInfo "After this operation, $megabytes MB of additional disk space will be used."
+    if ! $yesToPrompts; then
+      while true; do
+        printInfo "Do you want to continue? [y/n]"
+        read continueInstall < /dev/tty
+        if [ "y" = "${continueInstall}" ]; then
+          break;
+        fi
+        if [ "n" = "${continueInstall}" ]; then
+          mutexFree "zopen"
+          printInfo "Exiting..."
+          exit 0
+        fi
+      done
+    fi
+
+    if ! runLogProgress "pax -rf $pax -p p $paxredirect ${redirectToDevNull}" "Expanding $pax" "Expanded"; then
+      printWarning "Errors unpaxing, package directory state unknown"
+      printInfo    "Use zopen alt to select previous version"
+      continue;
+    fi
+    if $localInstall; then
+      rm -f "${pax}"
+    fi
+
+    if $setactive; then
+      if [ -L "$baseinstalldir/$name" ]; then
+        printVerbose "Removing old symlink '$baseinstalldir/$name'"
+        rm -f "$baseinstalldir/$name"
+      fi
+      if ! ln -s "$baseinstalldir/$installdirname" "$baseinstalldir/$name"; then
+        printError "Could not create symbolic link name"
+      fi 
+    fi 
+
+    printVerbose "Adding version '${downloadFileVer}' to info file"
+    # Add file version information as a .releaseinfo file
+    echo "$downloadFileVer" > "${baseinstalldir}/$installdirname/.releaseinfo"
+
+    # Check for a .version file from the pax - if present good, if not
+    # generate one from the file name as the tag isn't granular enough to really
+    # be used in dependency checks
+    if [ ! -f "${baseinstalldir}/$installdirname/.version" ]; then
+      echo "$downloadFileVer" > "${baseinstalldir}/$installdirname/.version"
+    fi
+    if $setactive; then
+      if ! $nosymlink; then
+        mergeIntoSystem "$name" "${baseinstalldir}/$installdirname" "$ZOPEN_ROOTFS" 
+        misrc=$?
+        printVerbose "The merge complete with: $misrc"
+      fi
+
+      printInfo "- Checking for env file"
+      if [ -f ${baseinstalldir}/${name}/.env ]; then
+        printInfo "- .env file found, adding to profiled processing"
+        mkdir -p "$ZOPEN_ROOTFS/etc/profiled/$name"
+        cat << EOF > "$ZOPEN_ROOTFS/etc/profiled/$name/dotenv"
+curdir=\$(pwd)
+cd "$baseinstalldir/$name" >/dev/null 2>&1
+if [ -f ".appenv" ]; then
+  . ./.appenv
+fi
+cd \$curdir  >/dev/null 2>&1
+EOF
+        printInfo "- Sourcing environment to run any setup"
+        cd "$baseinstalldir/$name" && "./setup.sh"
+      fi
+    fi
+    if $unInstallOldVersion; then
+      printVerbose "New version merged; checking for orphaned files from previous version"
+      # This will remove any old symlinks or dirs that might have changed in an upgrade
+      # as the merge process overwrites existing files to point to different version
+      unsymlinkFromSystem "$name" "$ZOPEN_ROOTFS" "$currentlinkfile"
+    fi
+    if $setactive; then
+      printVerbose "Marking this version as installed"
+      touch "${baseinstalldir}/${name}/.active"
+      installedList="$name $installedList"
+      syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_INSTALL,$CAT_PACKAGE" "DOWNLOAD" "handlePackageInstall" "Installed package:'$name';version:$downloadFileVer;install_dir='$baseinstalldir/$installdirname';"
+    fi
+
+    if $doNotInstallDeps; then
+        printInfo "- Skipping dependency installation"
+    elif $reinstall; then
+      printVerbose "- Reinstalling so no dependency reinstall (unless explicitly listed)"
+    else
+      printInfo "- Checking for runtime dependencies"
+      printVerbose "Checking for .runtimedeps file"
+      if [ -e "${baseinstalldir}/${name}/.runtimedeps" ]; then
+        dependencies=$(cat "${baseinstalldir}/${name}/.runtimedeps")
+      fi
+      printVerbose "Checking for runtime dependencies from the git metadata"
+      if echo "$statusline" | grep "Runtime Dependencies:" >/dev/null; then
+        gitmetadependencies="$(echo "$statusline" | sed -e "s#.*Runtime Dependencies:<\/b> ##" -e "s#<br />.*##")"
+        if [ ! "$gitmetadependencies" = "No dependencies" ]; then
+          dependencies="$dependencies $gitmetadependencies"
+        fi
+      fi
+      dependencies=$(deleteDuplicateEntries "$dependencies" " ")
+      if [ ! "x" = "x$dependencies" ]; then
+        printInfo "- $name depends on: $dependencies"
+        printInfo "- Installing dependencies"
+        installDependencies "$name" "$dependencies"
+      else
+        printInfo "- No runtime dependencies found"
+      fi
+    fi
+    printInfo "${NC}${GREEN}Successfully installed $name${NC}"
+  fi # (download only)
+}
+
+installPorts()
+(
+  ports="$1"
+  printVerbose "Ports to install: $ports"
+  echo "$ports" | xargs | tr ' ' '\n' | while read port; do
+    mutexReq "zopen" "zopen"
+    handlePackageInstall "$port"
+    mutexFree "zopen"
+  done
+)
+
+# Main code start here
+args=$*
+upgradeInstalled=false
+verbose=false
+selectVersion=false
+setActive=true
+cacheOnly=false
+downloadOnly=false
+localInstall=false
+reinstall=false
+installOrUpgrade=false
+nosymlink=false
+skipupgrade=false
+doNotInstallDeps=false
+all=false
+yesToPrompts=false
+chosenRepos=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    "-u" | "--update" | "-update" | "-upgrade" | "--upgrade")
+      upgradeInstalled=true
+      ;;
+    "-r" | "-reinstall" | "--reinstall")
+      reinstall=true
+      ;;
+    "--install-or-upgrade")
+      installOrUpgrade=true
+      ;;
+    "--local-install")
+      localInstall=true
+      ;;
+    "--no-symlink")
+      nosymlink=true
+      ;;
+    "--no-deps")
+      doNotInstallDeps=true
+      ;;
+    "--cache-only")
+      cacheOnly=true
+      ;;
+    "--release-line")
+      shift
+      releaseLine=$(echo "$1" | awk '{print toupper($0)}')
+      ;;
+    "--yes" | "-y")
+      yesToPrompts=true
+      ;;
+    "--download-only")
+      downloadOnly=true
+      ;;
+    "--no-set-active")
+      setactive=false
+      ;;
+    "--skip-upgrade")
+      skipupgrade=true
+      ;;
+    "--all")
+      all=true
+      ;;
+    "--select")
+      selectVersion=true
+      ;;
+    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+      printSyntax "${args}"
+      exit 4
+      ;;
+    "-v" | "--v" | "-verbose" | "--verbose")
+      verbose=true
+      ;;
+    "--version")
+      printVersion
+      exit 4
+      ;;
+    *)
+      chosenRepos="$chosenRepos $1";
+      ;;
+  esac
+  shift;
+done
+
+if [ -z "${chosenRepos}" ]; then
+  if ! $all && ! $upgradeInstalled; then
+    printInfo "No ports selected for installation"
+    exit 4
+  fi
+  if $upgradeInstalled; then
+    printVerbose "No specific port to upgrade, upgrade all installed packages"
+    printInfo "- Querying for installed packages"
+    progressHandler "spinner" "- Query complete" &
+    ph=$!
+    killph="kill -HUP $ph"
+    addCleanupTrapCmd "$killph"
+    chosenRepos="$(${utildir}/zopen-query list --installed --no-header --no-versions)"
+    $killph 2>/dev/null  # if the timer is not running, the kill will fail
+  elif $all; then
+    printInfo "Enter 'all' to confirm full installation [takes a long time so be sure!]:"
+    confirmall=$(getInput)
+    if [ ! "xall" = "x${confirmall}" ]; then
+      printError "Cancelling full installation"
+    fi
+  fi
+fi
+
+[ -z "${ZOPEN_CA}" ] && printError "\$ZOPEN_CA was not set. Ensure zopen init has run and \$HOME\zopen-config has been sourced."
+[ -r "${ZOPEN_CA}" ] || printError "Certificate at ${ZOPEN_CA} could not be accessed. Ensure zopen init has run and \$HOME\zopen-config has been sourced. "
+
+export SSL_CERT_FILE="${ZOPEN_CA}"
+export GIT_SSL_CAINFO="${ZOPEN_CA}"
+export CURL_CA_BUNDLE="${ZOPEN_CA}"
+
+if $downloadOnly | $localInstall; then
+  downloadDir=$PWD
+else
+  if [ -z "$ZOPEN_ROOTFS" ]; then
+    printError "Unable to locate zopen file system, \$ZOPEN_ROOTFS is undefined"
+  fi
+  downloadDir=$ZOPEN_ROOTFS/var/cache/zopen
+fi
+
+if [ ! -d "${downloadDir}" ]; then
+  mkdir -p "${downloadDir}"
+  if [ $? -gt 0 ]; then
+    printError "Could not create download directory: $downloadDir"
+  fi
+fi
+
+if [ -n "${downloadDir}" ] && [ -d "${downloadDir}" ]; then
+  cd "${downloadDir}"
+fi
+
+printVerbose "Working directory: ${downloadDir}"
+# Parse passed in repositories and check if valid zopen framework repos
+printInfo "- Querying remote repo for latest package information"
+getReposFromGithub
+grfgRc=$?
+$killph 2>/dev/null  # if the timer is not running, the kill will fail
+[ 0 -ne $grfgRc ] && exit $grfgRc;
+
+foundPort=false
+installArray=""
+
+if $all; then
+  for repo in $(echo ${repo_results}); do
+    installArray="$installArray $name"
+  done
+else
+  for chosenRepo in $(echo "${chosenRepos}" | tr ',' '\n'); do
+    printVerbose "Processing repo: $chosenrepo"
+    printVerbose "Stripping any version (%), tag (#) or port suffixes"
+    toolrepo=$(echo "$chosenRepo" | sed -e 's#%.*##' -e 's#=.*##' -e 's#.*port##')
+    printVerbose "Adding prefix and 'port' suffix" # quicker than testing for presence!
+    toolfound=$(echo "${repo_results}" | awk -vtoolrepo="$toolrepo" '$0 == toolrepo {print}') 
+    if [ "$toolfound" = "$toolrepo" ]; then
+      printVerbose "Adding '$chosenRepo' to the install queue"
+      installArray="$installArray $chosenRepo"
+      printVerbose "Removing valid port from input list"
+      chosenRepos=$(echo "$chosenRepos" | sed -e "s#$chosenRepo##")
+    fi
+  done
+fi
+printVerbose "Checking whether any ports remain in the input list"
+chosenRepos=$(strtrim "$chosenRepos")
+if [ -n "$chosenRepos" ]; then
+  printError "The following requested port(s) do not exist:\n\t$(echo $chosenRepos | tr -s '[:space:]')"
+fi
+
+installPorts "$installArray"
diff --git a/bin/lib/zopen-init b/bin/lib/zopen-init
index 150f409cf..a496deb62 100755
--- a/bin/lib/zopen-init
+++ b/bin/lib/zopen-init
@@ -1,46 +1,472 @@
 #!/bin/sh
-#
-# Creates a $HOME/.zopen-config file
-#
-export utildir="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
+# Initialize zopen
 
+if [ -z "$utildir" ]; then
+  export utildir="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
+fi
 . "${utildir}/common.inc"
 
 printSyntax() 
 {
   args=$*
-  echo "zopen-init will initialize zopen (create a $HOME/.zopen-config file)" >&2
+  echo "zopen init will initialize the zopen filesystem and configuration (create a $HOME/.zopen-config file)" >&2
+  echo "Syntax: zopen init [<option>] [<root-dir>]" >&2
+  echo "  where <option> can be one or more of:" >&2
+  echo "  -f <type>: virtual filesystem location for package management; packages will be installed to this location under the <root-dir>" >&2
+  echo "      usrlclz - /usr/local/zopen (default);" >&2 
+  echo "      zopen - /usr/zopen (default);" >&2
+  echo "      prod - zopen standard;" >&2
+  echo "      ibm  - /usr/lpp;" >&2
+  echo "      fhs  - File Hierarchical Standard (/opt)"  >&2
+  echo "      usrlcl - /usr/local;">&2
+  echo "  --re-init: re-initialize a previous installation (if present).  Re-initializing over a previous installation will re-use existing package structures and configurations." >&2
+  echo "  --clone: clones the current installation to a different location" >&2
+  echo "  --append-to-profile: appends sourcing of .zopen-config to .profile" >&2
+  echo "  -v: run in verbose mode" >&2
+  echo "  -?|-h|--help: display help" >&2
 }
 
+args=$*
+
+verbose=false
+reinitExisting=false
+clone=false
+appendToProfile=false
+fslayout="usrlclz"
+while [ $# -gt 0 ]; do
+  case "$1" in
+    "-f" | "--fs-layout" )
+      fslayout=$2
+      shift
+      ;;
+    "--re-init" )
+      reinitExisting=true
+      ;;
+    "--clone" )
+      clone=true
+      ;;
+    "--append-to-profile" )
+      appendToProfile=true
+      ;;
+    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+      printSyntax "${args}"
+      exit 4
+      ;;
+    "-v" | "--v" | "-verbose" | "--verbose")
+       verbose=true
+      ;;
+    *)
+      rootfs=$1;
+      ;;
+  esac
+  shift;
+done
+case "$fslayout" in
+  fhs|ibm|prod|zopen|usrlcl|usrlclz)
+  ;;
+  *)
+    printError "${NC}${RED}The filesystem layout $fslayout is unrecognised"
+    ;;
+esac
 printHeader "Initialize zopen framework"
 
-echo "Enter the path to your zopen install directory (default: $HOME/zopen)"
-zopen_path=$(getInput)
+configFile="$HOME/.zopen-config"
+
+if $clone; then
+  [ ! -e "$configFile" ] && printError "- Unable to clone existing configuration; configuration file $configFile could not be read"
+  printInfo "- Cloning existing configuration"
+  configFile=".zopen-config.clone"
+elif [ -e "$configFile" ]; then
+  if ! $reinitExisting; then
+    printWarning "- Existing configuration file found; re-initializing might lose access to previously installed packages. Continue (y/n)?"
+    reinit=$(getInput)
+  fi
+  if $reinitExisting || { [ -n "$reinit" ] && [ "y" = "${reinit}" ]; }; then
+    printInfo "- Re-initializing; removing existing .zopen-config"
+    rmrf=$(rm -rf "$configFile")
+  else
+    printWarning "- Stopping. Pre-existing configuration will be preserved"
+    exit 8
+  fi
+fi
 
-# If the user did not enter a path, use the default
-if [ -z "$zopen_path" ]; then
-  zopen_path="$HOME/zopen"
+if [ -n "$ZOPEN_ROOT_PATH" ]; then
+  rootfs="$ZOPEN_ROOT_PATH"
+  printInfo "- Setting root directory from ZOPEN_ROOT_PATH envvar: $rootfs"
 fi
 
-if [ ! -e "$zopen_path/prod" ]; then
-  mkdir -p "$zopen_path/prod"
+if [ -z "$rootfs" ]; then
+  if $clone; then
+    printInfo "- Enter fully-qualified path to clone-target directory:"
+  else
+    printInfo "- Enter fully-qualified path to your zopen root directory (default: $HOME/zopen)"
+  fi
+  rootfs=$(getInput)
+else
+  printInfo "- Setting root directory from cli: $rootfs"
 fi
-if [ ! -e "$zopen_path/boot" ]; then
-  mkdir -p "$zopen_path/boot"
+
+if [ -z "$rootfs" ]; then
+  if $clone; then
+    printError "- No target location for clone. Stopping."
+  fi
+  printInfo "- No explicit root set, using default: \$HOME/zopen"
+  rootfs="$HOME/zopen"
+else
+  if [ "${rootfs%/}" = '/' ]; then
+    printInfo "- Stripping trailing '/' char"
+    rootfs="${rootfs%})"
+  fi
+  if [ "$rootfs" = "/" ]; then
+    printInfo "- Installing into system root; are you sure (y/N)?"
+    sysrootok=$(getInput)
+    if [ -n "$sysrootok" ] && [ "y" = "${sysrootok}" ]; then
+      printInfo "- Using '/' as root filesystem"
+      rootfs="/." # references below take a root directory
+    else
+      printWarning "- Stopping. Existing configuration will be preserved"
+      exit 4
+    fi
+  fi
 fi
 
-echo "Enter the github oauth token for use in zopen-download. If none, press enter"
-zopen_oauth=$(getInput)
-if [ ! -z "$zopen_oauth" ]; then
-  zopen_oauth="export ZOPEN_GITHUB_OAUTH_TOKEN=$zopen_oauth"
+if ! $clone; then
+  printInfo "Checking for existence of specified root: '$rootfs'"
+  [ -e "$rootfs" ] || mkdir -p "$rootfs" || printError "Unable to create zopen root filesystem at '$rootfs'"
+  [ -d "$rootfs" ] || printError "Specified location '$rootfs' is not a directoryUnable to access root file system at '$rootfs'; check permissions"  
+  [ -w "$rootfs" ] || printError "Unable to access root file system at '$rootfs'; check permissions"  
+
+  printInfo "- Populating standard file system"
+  [ -e "$rootfs/bin" ] || mkdir -p "$rootfs/bin"
+  [ -e "$rootfs/etc" ] || mkdir -p "$rootfs/etc"
+  [ -e "$rootfs/etc/skel" ] || mkdir -p "$rootfs/etc/skel"
+  [ -e "$rootfs/include" ] || mkdir -p "$rootfs/include"
+  [ -e "$rootfs/usr/share" ] || mkdir -p "$rootfs/usr/share"
+  [ -e "$rootfs/usr/share/man" ] || mkdir -p "$rootfs/usr/share/man"
+  [ -e "$rootfs/usr/share/zopen" ] || mkdir -p "$rootfs/usr/share/zopen"
+  [ -e "$rootfs/var/cache/zopen" ] || mkdir -p "$rootfs/var/cache/zopen"
+  [ -e "$rootfs/var/log" ] || mkdir -p "$rootfs/var/log"
+  [ -e "$rootfs/var/tmp" ] || mkdir -p "$rootfs/var/tmp"
+  
+  printInfo "- Creating path for bootstrap files"
+  [ -e "$rootfs/boot" ] || mkdir -p "$rootfs/boot"
+  
+  printInfo "- Creating symbolic path for prod redirect files"
+  [ -e "$rootfs/usr/share/zopen/boot" ] || ln -s "$rootfs/boot" "$rootfs/usr/share/zopen/boot"
+  case "$fslayout" in
+    "usrlclz")
+      zopen_pkginstall="usr/local/zopen"
+    ;;
+    "usrlcl")
+      zopen_pkginstall="usr/local"
+    ;;
+    "fhs")
+      zopen_pkginstall="opt"
+    ;;
+    "ibm")
+      zopen_pkginstall="usr/lpp"
+    ;;
+    "prod")
+      zopen_pkginstall="prod"
+    ;;
+    "zopen")
+      zopen_pkginstall="usr/zopen"
+    ;;
+  esac
+  [ -e "$rootfs/etc/zopen" ] || mkdir -p "$rootfs/etc/zopen"
+  echo "$zopen_pkginstall" > "$rootfs/etc/zopen/fstype"
+  
+  [ -e "$rootfs/$zopen_pkginstall" ] || mkdir -p "$rootfs/$zopen_pkginstall"
+  [ -e "$rootfs/usr/share/zopen/prod" ] || ln -s "$rootfs/$zopen_pkginstall" "$rootfs/usr/share/zopen/prod"
+else
+  printVerbose "Grabbing pkginstall location from within cloned env"
+  if [ -e "$ZOPEN_ROOTFS/etc/zopen/fstype" ]; then
+    zopen_pkginstall=$(cat "$rootfs/etc/zopen/fstype")
+  else
+    printError "Unable to locate $ZOPEN_ROOTFS/etc/zopen/fstype; cannot clone unrecognisable file system"
+  fi
+fi
+
+if [ "$ZOPEN_PKGINSTALL" = "$rootfs" ]; then
+   printWarning "Package install location is the zopen root location; this is not recommended. Continue (y/n)"
+   pkgoverlaysrootfs=$(getInput)
+   if [ -n "$pkgoverlaysrootfs" ] && [ "y" = "${pkgoverlaysrootfs}" ]; then
+     printInfo "- Continuing. Packages will be installed into the zopen root location: $rootfs"
+   else
+     printWarning "- Stopping. Existing configuration will be preserved"
+     exit 8
+   fi
+fi
+
+ZOPEN_CA_DIR="etc/pki/tls/certs"  # TODO: Work out "proper" location
+if ! $clone; then
+    printInfo "- Creating path for certificate lookups"
+    [ -e "$rootfs/$ZOPEN_CA_DIR" ] || mkdir -p "$rootfs/$ZOPEN_CA_DIR"
+fi
+
+# Save the configuration to the file - overwrite any existing file with the title initially
+echo "# z/OS Open Tools Configuration file" > "$configFile"
+echo "# Main root location for the zopen installation; can be changed if the " >> "$configFile"
+echo "# underlying root location is copied/moved elsewhere as locations are " >> "$configFile"
+echo "# relative to this envvar value" >> "$configFile"
+echo "ZOPEN_ROOTFS=$rootfs" >> "$configFile"
+echo "export ZOPEN_ROOTFS" >> "$configFile"
+echo "configStartTime=\$SECONDS" >> "$configFile"
+echo "zot=\"z/OS Open Tools\"" >> "$configFile"
+
+# Add the profiled processing first so the zopen paths are added first
+cat << EOF >>  "$configFile"
+# Temporary file location
+for tmp in "\$TMPDIR" "\$TMP" /tmp
+do
+  if [ ! -z \$tmp ] && [ -d \$tmp ]; then
+    break
+  fi
+done
+
+if [ ! -d "\$tmp" ]; then
+  echo "Temporary directory not found. Specify \$TMPDIR, \$TMP or have a valid /tmp directory"
+fi
+TMP_FIFO_PIPE="\$tmp/zopen_\$LOGNAME.configFile.pipe"
+
+# Set Traps
+atExit() {
+  sig=\$?
+  [ -p \$TMP_FIFO_PIPE ] && rm -rf \$TMP_FIFO_PIPE
+  trap - EXIT INT TERM QUIT HUP
+  exit \$sig
+}
+
+trap "atExit" EXIT INT TERM QUIT HUP
+
+sanitizeEnvVar(){
+  # remove any envvar entries that match the specified regex
+  value=\$1
+  delim=\$2
+  prefix=\$3
+  echo "\$value" | awk -v RS="\$delim" -v DLIM="\$delim" -v PRFX="\$prefix" '{ if (match(\$1, PRFX)==0) {printf("%s%s",\$1,DLIM)}}'
+}
+
+deleteDuplicateEntries() 
+{
+  value=\$1
+  delim=\$2
+  echo "\$value\$delim" | awk -v RS="\$delim" '!(\$0 in a) {a[\$0]; printf("%s%s", col, \$0); col=RS; }' | sed "s/\${delim}$//"
+}
+
+# z/OS Open Tools environment variables
+ZOPEN_PKGINSTALL=\$ZOPEN_ROOTFS/$zopen_pkginstall
+export ZOPEN_PKGINSTALL
+ZOPEN_SEARCH_PATH=\$ZOPEN_ROOTFS/usr/share/zopen/
+export ZOPEN_SEARCH_PATH
+ZOPEN_CA=\$ZOPEN_ROOTFS/$ZOPEN_CA_DIR/cacert.pem
+export ZOPEN_CA
+ZOPEN_LOG_PATH=\$ZOPEN_ROOTFS/var/log
+export ZOPEN_LOG_PATH
+
+# Tool environment variables
+if [ -z "\$ZOPEN_QUICK_LOAD" ]; then
+  if [ -e "\$ZOPEN_ROOTFS/etc/profiled" ]; then
+    dotenvs=\$(find "\$ZOPEN_ROOTFS/etc/profiled" -type f -name 'dotenv' -print)
+    dotenvcnt=\$(echo "\$dotenvs" | wc -l | tr -d ' ')
+    filecnt=0
+    [ ! -p \$TMP_FIFO_PIPE ] || rm -f \$TMP_FIFO_PIPE
+    mkfifo \$TMP_FIFO_PIPE
+    chtag -tc 819 \$TMP_FIFO_PIPE
+    /bin/echo "\$dotenvs" | xargs | tr ' ' '\n'>>\$TMP_FIFO_PIPE &
+    while read FILE; do
+      filecnt=\$(expr \$filecnt + 1)
+      pct=\$(expr \$filecnt \* 100)
+      pct=\$(expr \$pct / \$dotenvcnt)
+      /bin/echo "\047[1A\047[$30D\047[2K- Processing \$zot configuration: \${pct}% (\${filecnt}/\${dotenvcnt})"
+      [ -e \$FILE ] && . \$FILE
+    done < \$TMP_FIFO_PIPE
+    [ ! -p \$TMP_FIFO_PIPE ] || rm -f \$TMP_FIFO_PIPE
+    /bin/echo "\047[1A\047[\$30D\047[2K- Processed \$zot configuration: 100% (\${dotenvcnt}/\${dotenvcnt})"
+    unset dotenvs dotenvcnt filecnt
+  fi
 fi
+PATH=\$ZOPEN_ROOTFS/usr/bin:\$ZOPEN_ROOTFS/bin:\$ZOPEN_ROOTFS/boot:\$(sanitizeEnvVar \"\$PATH\" \":\" \"^\$ZOPEN_PKGINSTALL/.*\$\")
+export PATH=\$(deleteDuplicateEntries \"\$PATH\" \":\")
+LIBPATH=\$ZOPEN_ROOTFS/usr/lib:\$(sanitizeEnvVar "\$LIBPATH" ":" "^\$ZOPEN_PKGINSTALL/.*\$")
+export LIBPATH=\$(deleteDuplicateEntries \"\$LIBPATH\" \":\")
+MANPATH=\$ZOPEN_ROOTFS/usr/share/man:\$ZOPEN_ROOTFS/usr/share/man/\%L:\$(sanitizeEnvVar \"\$MANPATH\" \":\" \"^\$ZOPEN_PKGINSTALL/.*\$\")
+export MANPATH=\$(deleteDuplicateEntries \"\$MANPATH\" \":\")
+
+unset tmp TMP_FIFO_PIPE
+
+# Unset traps
+trap - EXIT INT TERM QUIT HUP
+EOF
+
+skeletonDir="$rootfs/etc/skel"
+skelcfg="$skeletonDir/.zopen-config"
+printVerbose "Copying configuration file to $skeletonDir for backup/distribution"
+cp "$configFile" "$skelcfg"
+printVerbose "Adding git oauth token placeholder and footer to skeleton file"
+cat << EOF >>  "$skelcfg"
+/bin/echo "- \$zot configuration completed in \$(( \$SECONDS - \$configStartTime )) seconds."
+EOF
+perms="744"
+printVerbose "Giving world read access to skel config file"
+chmod "$perms" "$skelcfg"
+
+perms="400"
+printVerbose "Setting user configuration file [$configFile] as read-only for user, no access to others [$perms]"
+chmod "$perms" "$configFile"
+effuid=$LOGNAME
+effgid=$(id -gn $effuid)
+printVerbose "Ensuring correct uid [$effuid] & gid [$effgid] for configfile if !installing as user (ie su/root/etc)"
+chown "$effuid" "$configFile"
+chgrp "$effgid" "$configFile"
+printInfo "- Created config in $configFile."
+
+printInfo "- Root FS available at $rootfs"
+
+if $clone; then
+  printInfo "- Cloning from $ZOPEN_ROOTFS to $rootfs"
+  cp -fRT "$ZOPEN_ROOTFS" "$rootfs"
+  printInfo "${NC}${CYAN}- Run '. $configFile' to enable cloned environment for current session${NC}"
+  printInfo "${NC}${CYAN}- or manually copy cloned configuration to required location and/or modify .profile"
+  syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_PACKAGE,$CAT_FILE" "INIT" "" "zopen environment cloned to $rootfs"
+  printInfo "${NC}${GREEN}zopen clone complete.${NC}"
+else
+  export ZOPEN_ROOTFS="$rootfs"
+
+  # Generate any system values that can be user changed
+  echo "15" > "$rootfs/etc/zopen/rm_fileprocs"
 
+  printInfo "- Check for shipped curl pax"
+  curlpax="packages/curl-8.1.2.20230707_145137.zos.pax.Z"
 
-# Save the configuration to the file
+  curllcn=$(findrev "${utildir}" "$curlpax")
+  echo "$curllcn/$curlpax"
+  if [ -e "$curllcn/$curlpax" ]; then
+    printInfo "- Found $curlpax. Adding to zopen cache to install as bootstrap"
+    cp -f "$curllcn/$curlpax" "$rootfs/var/cache/zopen"
+  else
+    printError "Could not locate curl pax in the zopen cache"
+  fi
+  printVerbose "- Expanding curl to bootstrap dir..."
+  cachedir="$rootfs/var/cache/zopen"
+  basecurlpax=$(basename $curlpax)
+  [ -e "$cachedir/$basecurlpax" ] || printError "Could not locate bootstrap curl pax."
+  paxrc=$(pax -rf "$cachedir/$basecurlpax" -s##$rootfs/boot/#)
 
-cat <<zz >"${HOME}/.zopen-config"
-export ZOPEN_SEARCH_PATH=$zopen_path
-$zopen_oauth
-zz
+  printInfo "- Check for shipped jq pax"
+  jqpax="packages/jq-1.6.20230720_160648.zos.pax.Z"
 
-printInfo "Creating config in $HOME/.zopen-config"
+  jqlcn=$(findrev "${utildir}" "$jqpax")
+  if [ -e "$jqlcn/$jqpax" ]; then
+    printInfo "- Found $jqpax. Adding to zopen cache to install as bootstrap"
+    cp -f "$jqlcn/$jqpax" "$rootfs/var/cache/zopen"
+  else
+    printError "$jqpax not found"
+  fi
+  printVerbose "- Expanding jq to bootstrap dir..."
+  cachedir="$rootfs/var/cache/zopen"
+  basejqpax=$(basename $jqpax)
+  [ -e "$cachedir/$basejqpax" ] || printError "Could not locate bootstrap jq pax."
+  paxrc=$(pax -rf "$cachedir/$basejqpax" -s##$rootfs/boot/#)
+
+  cacertlcn=$(findrev "${utildir}" "cacert.pem")
+  if [ -e "$cacertlcn/cacert.pem" ]; then
+    printInfo "- Found default cacert.pem; copying to zopen file system"
+    cp -f "$cacertlcn/cacert.pem" "$ZOPEN_ROOTFS/$ZOPEN_CA_DIR"
+  else
+    printError "Could not locate default cacert.pem at '../cacert.pem'."
+  fi
+
+  if [ -r "$ZOPEN_ROOTFS/$ZOPEN_CA_DIR/cacert.pem" ]; then
+    printInfo "- Setting certificate envvar"
+    export SSL_CERT_FILE="$ZOPEN_ROOTFS/$ZOPEN_CA_DIR/cacert.pem"
+  else
+    printError "- Could not locate cacert.pem at '$ZOPEN_ROOTFS/$ZOPEN_CA_DIR'"
+  fi
+  
+  # Need to source the .env file from within the actual curl directory and cannot
+  # spawn sub-process otherwise no access to environment from this script so run inline
+  curldir="$(ls $rootfs/boot | grep curl)"
+  [ -e "$rootfs/boot/$curldir" ] || printError "Could not locate curl for bootstrap. Re-run 'zopen init' to retry"
+  chmod -R 755 "$rootfs/boot/$curldir"
+  curwd=$PWD
+  cd "$rootfs/boot/$curldir/" || printError "Could not access boot curl directory. Re-run 'zopen init' to retry"
+  . ./.env
+  cd "$curwd"  || printError "Could not change to $curwd. Re-run 'zopen init' to retry"
+
+  jqdir="$(ls $rootfs/boot | grep jq)"
+  [ -e "$rootfs/boot/$jqdir" ] || printError "Could not locate jq for bootstrap. Re-run 'zopen init' to retry"
+  chmod -R 755 "$rootfs/boot/$jqdir"
+  curwd=$PWD
+  cd "$rootfs/boot/$jqdir/" || printError "Could not access boot curl directory. Re-run 'zopen init' to retry"
+  . ./.env
+  cd "$curwd"  || printError "Could not change to $curwd. Re-run 'zopen init' to retry"
+  
+  printInfo "- Updating CA cert"
+  ZOPEN_CA="$ZOPEN_ROOTFS/$ZOPEN_CA_DIR"
+  mkdir -p "$ZOPEN_CA"
+  ZOPEN_CA="$ZOPEN_CA/cacert.pem"
+  export ZOPEN_CA
+  runAndLog "${utildir}/zopen-update-cacert -f"
+  printInfo "- Sourcing environment"
+  . "$configFile"
+  printInfo "- Using bootstrapped curl and jq to install latest release of itself (if available)"
+  curlInstall=$(runAndLog "${utildir}/zopen-download curl jq")
+  curlInstall=$?
+  [ $curlInstall -ne 0 ] && printError "Unable to install curl and jq; see previous errors and retry the initilisation using the '--re-init' parameter"
+  . "$configFile"
+
+  # Code to use this version of meta as "official" install - pin to ensure no overwriting
+  printInfo "- Installing and pinning currently running version of meta" 
+  printVerbose "Current dir: $utildir"
+  metadtInstDir="$ZOPEN_ROOTFS/$zopen_pkginstall/meta-dt"
+  printVerbose "Meta will be installed to $metadtInstDir"
+  mkdir -p "$metadtInstDir"
+
+  if [ -L "$0" ]; then
+    printVerbose "Found a link"
+    # We are running zopen from within a zopen-environment already
+    # De-reference symlinks to get the actual meta location. On a re-init,
+    # this might correlate to the existing location so we can reuse it; otherwise
+    # we need to copy the existing meta to the new location
+    physical="$(ls -l "$0" | sed -e "s/.*-> //")" 
+    full="$(dirname $0)/$physical"
+    real="$(dirname $full)"
+    deref="$( cd "$real/../.." >/dev/null 2>&1 && pwd -P )"
+    
+    if [ "$deref" = "$metadtInstDir" ]; then
+      printInfo "- Re-initialising target is current; no action required"
+    else
+      printInfo "- Copying existing meta to re-initialised location"
+      cp -fRT "$deref/"  "$metadtInstDir"
+    fi
+    
+  else
+    printVerbose "Copying local meta; work out where to find all files"
+    cp -fRT "${utildir}/../../"  "$metadtInstDir" 
+  fi
+
+  printInfo "- Running alternative utility to force selection of forked meta"
+  # Can use "1" as the default since there should be no other options during init!
+  metaInstall=$(runAndLog "${utildir}/zopen-alt meta -s -d 1")
+  metaInstall=$?
+  [ $metaInstall -ne 0 ] && printError "Unable to install meta; see previous errors and retry the initilisation using the '--re-init' parameter"
+
+  #TODO: Reinstate following code should this fork merge
+  #printInfo "- Installing latest version of meta package into zopen system"
+  #runAndLog "${utildir}/zopen-download meta"
+
+  printInfo "- zopen bootstrapping complete"
+
+  if $appendToProfile; then
+    if ! grep -q ". \$HOME/.zopen-config" "$HOME/.profile"; then
+      printVerbose "Line not present (grep returned non-0)"
+  cat << EOF >>  "$HOME/.profile"
+  [ -e "\$HOME/.zopen-config" ] && . \$HOME/.zopen-config
+EOF
+    fi
+  fi
+  printInfo "${NC}${YELLOW}- Run '. \$HOME/.zopen-config' to enable zopen environment for current session${NC}"
+  syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_PACKAGE,$CAT_FILE" "INIT" "" "zopen environment initialised as $ZOPEN_ROOTFS"
+  printInfo "${NC}${GREEN}zopen initialization complete.${NC}"
+fi
diff --git a/bin/lib/zopen-query b/bin/lib/zopen-query
new file mode 100755
index 000000000..d8efba901
--- /dev/null
+++ b/bin/lib/zopen-query
@@ -0,0 +1,324 @@
+#!/bin/sh
+# Query utility for z/OS Open Tools - https://github.com/ZOSOpenTools
+
+export utildir="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
+
+. "${utildir}/common.inc"
+
+printSyntax() 
+{
+  args=$*
+  echo "zopen query is a utility for z/OS Open Tools to query packages and repos." >&2
+  echo "Syntax: zopen-query [<option>]* [<package]*" >&2
+  echo "  where <option> may be one or more of:" >&2
+  echo "  --list: list all available z/OS Open Tools."  >&2
+  echo "  --remote-search: check for package in z/OS Open Tools repo" >&2
+  echo "  -i : --installed: list install z/OS Open Tools." >&2
+  echo " --upgradeable: list packages where an upgrade is available." >&2
+#TODO echo "  --provides: list the files that an installed package provides." >&2
+  echo "  -wp : --whatprovides: which installed package provided a file." >&2
+  echo "  -v: run in verbose mode." >&2
+  echo "  -d | --details: include full details for listings." >&2
+  echo "  --no-header: suppress the header for the output." >&2
+  echo "  --no-version:  suppress version information, return package names." >&2
+  echo "  --filter <color>: apply filter based on quality (green - all tests passing, blue - most tests passing, yellow - some tests passing, red - no tests passing, or skipped (no filter by default))"  >&2
+  echo " and <package> is an optional list of one or more packages." >&2
+}
+
+printDetailListEntries()
+{
+  details=$1
+  needle=$2
+  onlyUpgradesAvailable=$3
+
+  if [ $details -eq 0 ]; then
+    scrcols=$(getScreenCols)
+    numcols=4
+    colwidth=$(($scrcols / $numcols -1 ))
+    if [ ! -z "$1" ] && ! $noheader; then
+      printf "${NC}${UNDERLINE}%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s\n${NC}" "Package" "Your version" ".version" "Latest Tag"
+    fi
+    echo "$repoArray" | xargs | tr ' ' '\n' | sort | while read repo; do
+      if [ -z $needle ] || [ "${repo}" = "${needle}" ]; then
+        latest=$(jq -e -r '.release_data."'$repo'"[0]' "$JSON_CACHE")
+        if [ $? -ne 0 ]; then
+          printError "Unable to retrieve remote information"
+        fi
+        latestTag=$(/bin/printf "%s" "$latest" | jq -e -r '.tag_name')
+        if [ -e "${ZOPEN_PKGINSTALL}/${repo}/.releaseinfo" ]; then
+          originalTag=$(cat "${ZOPEN_PKGINSTALL}/${repo}/.releaseinfo")
+        else
+          originalTag="Not installed"
+        fi
+        if [ -e "${ZOPEN_PKGINSTALL}/${repo}/.version" ]; then
+          dotversion=$(cat "${ZOPEN_PKGINSTALL}/${repo}/.version")
+        else
+          dotversion="N/A"
+        fi
+        if [ $onlyUpgradesAvailable -gt 0 ]; then
+          if [ "$originalTag" = "Not installed" -o "$originalTag" = "$latestTag" ]; then
+            continue;
+          fi 
+        fi
+        if ! $noversions; then
+          printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s\n" "$repo" "$originalTag" "$dotversion" "$latestTag"
+        else
+          printf "%s\n" "$repo"
+        fi
+      fi 
+    done
+  else
+    printVerbose "Checking repoArray: $repoArray"
+    scrcols=$(getScreenCols)
+    numcols=6
+    colwidth=$(($scrcols / $numcols -1 ))
+    if ! $noheader; then
+      printf "${NC}${UNDERLINE}%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s\n${NC}" "Package" "Your version" "Latest Tag" "Download Size" "Expanded Size" "Quality"
+    fi
+    echo "$repoArray" | xargs | tr ' ' '\n' | sort | while read repo; do
+      if [ -z $needle ] || [ "${repo}" = "${needle}" ]; then
+        if [ -e "${ZOPEN_PKGINSTALL}/${repo}/.releaseinfo" ]; then
+          originalTag=$(cat "${ZOPEN_PKGINSTALL}/${repo}/.releaseinfo")
+        else
+          originalTag="Not installed"
+        fi
+        latest=$(jq -e -r '.release_data."'$repo'"[0]' "$JSON_CACHE")
+        case $? in
+          1) printVerbose "No latest release for port";
+               printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s %-${colwidth}s ${NC}${RED}%-${colwidth}s${NC}\n" "$repo" "$originalTag" "Unknown" "Unknown" "Unknown" "Unknown" 
+               ;;
+          0) printVerbose "Latest release request successful";  
+               latestTag="$(/bin/printf "%s" "$latest" | jq -e -r '.tag_name')"
+               passed="$(/bin/printf "%s" "$latest" | jq -e -r '.assets[0].passed_tests')"
+               total="$(/bin/printf "%s" "$latest" | jq -e -r '.assets[0].total_tests')"
+               expandedsize="$(/bin/printf "%s" "$latest" | jq -e -r '.assets[0].expanded_size')"
+               downloadsize="$(/bin/printf "%s" "$latest" | jq -e -r '.assets[0].size')"
+               if [ $onlyUpgradesAvailable -gt 0 ]; then
+                 if [ "$originalTag" = "Not installed" -o "$originalTag" = "$latestTag" ]; then
+                   continue;
+                 fi 
+               fi
+               if [ $total -gt 0 ]; then
+                 percentage=$(echo "scale=0; 100 * ($passed) / $total" | bc)
+               fi
+               printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s " "$repo" "$originalTag" "$latestTag" 
+               if [ -z "$percentage" ]; then
+                printf "${NC}${RED}%-${colwidth}s${NC}" "No tests"
+               elif [ $percentage -eq 100 ]; then
+                printf "${NC}${GREEN}%-${colwidth}s${NC}" "$percentage%"
+               elif [ $percentage -gt 50 ]; then
+                printf "${NC}${BLUE}%-${colwidth}s${NC}" "$percentage%"
+               elif [ $percentage -gt 0 ]; then
+                printf "${NC}${YELLOW}%-${colwidth}s${NC}" "$percentage%"
+               else
+                printf "${NC}${RED}%-${colwidth}s${NC}" "$percentage%"
+               fi
+               printf " %-${colwidth}s"  "$expandedsize"
+               printf " %-${colwidth}s"  "$downloadsize"
+               printf "\n"
+               ;;
+          *) printError "Error $httpResponseCode while trying to retrieve latest repo release";;
+        esac
+
+      fi
+      continue;   
+    done
+  fi
+  exit 0
+}
+printInstalledEntries(){
+  scrcols=$(getScreenCols)
+  numcols=3
+  colwidth=$(($scrcols / $numcols -1 ))
+  if [ ! -z "$1" ] && ! $noheader; then
+    printf "${NC}${UNDERLINE}%-${colwidth}s %-${colwidth}s %-${colwidth}s\n${NC}" "Package" "Installed version" "File version"
+  fi
+  installedPackages="$(zosfind $ZOPEN_PKGINSTALL -name .active 2>/dev/null)"
+  printVerbose "Packages: $installedPackages"
+  echo "$installedPackages" | xargs | tr ' ' '\n' | sort | while read repo; do
+    pkghome=$(dirname "${repo}")
+    if [ -e "${pkghome}/.releaseinfo" ]; then
+      originalTag=$(cat "${pkghome}/.releaseinfo")
+    else
+      originalTag="N/A"
+    fi
+    if [ -e "${pkghome}/.version" ]; then
+      dotversion=$(cat "${pkghome}/.version")
+    else
+      dotversion="N/A"
+    fi
+
+    printVerbose "Original tag: $originalTag for repo: $repo"
+    if [ -z "$1" ]; then
+      printInfo "$originalTag"
+    else
+      fileversion="$( cd "$(dirname "$repo")" >/dev/null 2>&1 && pwd -P | xargs basename)"
+      reponame=$(dirname "$repo" | xargs basename)
+      if ! $noversions; then
+        printf "%-${colwidth}s %-${colwidth}s %-${colwidth}s\n" "$reponame" "$dotversion" "$fileversion"
+      else
+        printf "%s\n" "$reponame"
+      fi
+    fi
+  done
+  exit 0
+}
+
+
+whatProvides(){
+  needle=$1
+  printVerbose "Finding matches outside the ZOPEN_PKGINSTALL ($ZOPEN_PKGINSTALL)"
+  # Find any symlinks that match the name and can then be dereferenced
+  found=$(zosfind $ZOPEN_ROOTFS/usr -type l | grep "${needle}")
+  printVerbose "Found? '$found'"
+  if [[ -z $found ]]; then
+    printInfo "No package provides '${needle}'"
+  else
+    matches=$(echo "$found"| wc -w | tr -d ' ' ) 
+    printInfo "Found ${matches} match$([ $matches = 1 ] && echo "" || echo "es") for regex '${needle}' on the system"
+    echo "$found" | xargs | tr ' ' '\n' | while read foundmatch; do
+      printVerbose "Parsing $foundmatch"
+      if [ ! -d $foundmatch ]; then
+        deref=$(ls -l $foundmatch | awk '{ print $(NF) }')
+        printVerbose "$ZOPEN_PKGINSTALL  -> $deref"
+        printVerbose "${deref#$ZOPEN_PKGINSTALL}"
+        pkg=$(echo "${deref#$ZOPEN_PKGINSTALL}" | awk -F/ '{print $2}')
+        printInfo "$pkg provides '$foundmatch'"
+      fi
+    done
+  fi
+  exit 0
+}
+
+# Main code start here
+args=$*
+verbose=false
+noheader=false
+noversions=false
+localoption=true
+upgradeable=false
+details=0
+needle=
+if [[ $# -eq 0 ]]; then
+  printError "No option provided for query"
+fi
+
+while [[ $# -gt 0 ]]; do
+  printVerbose "Parsing option: $1"
+  case "$1" in
+    "--list")
+      list=1;
+      localoption=false;
+      ;;
+    "-i" | "--installed")
+      localoption=true;
+      installed=1;
+      list=;
+    ;;
+    "-wp" | "--whatprovides")
+      localoption=true;
+      whatprovides=1;
+      shift;
+      [ ! -z $1 ] || printError "Missing file argument";
+      needle=$1;
+    ;;
+    "--remote-search")
+      localoption=false;
+      remotesearch=1;
+      shift;
+      [ ! -z $1 ] || printError "Missing package argument";
+      needle=$1;
+    ;;
+    "--no-header")
+      noheader=true;
+    ;;
+    "--upgradeable")
+      upgradeable=true;
+    ;;
+    "--no-versions")
+      noversions=true;
+      noheader=true; # headers do not mean anything without versions!
+    ;;
+    "-f" | "--filter")
+      filter=$2;
+      shift
+      ;;
+    "-d"  | "--details")
+      details=1;
+    ;;
+    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+      printSyntax "${args}"
+      exit 4
+      ;;
+    "-v" | "--v" | "-verbose" | "--verbose")
+      verbose=true
+      ;;
+    -*)
+      printError "Unknown option '$1'"
+      ;;
+     
+    *)
+      chosenRepos="$chosenRepos $1";
+      ;;
+  esac
+  shift;
+done
+
+[[ ! -z "${ZOPEN_CA}" ]] || printError "\$ZOPEN_CA was not set. Ensure zopen init has run and \$HOME\zopen-config has been sourced."
+[[ -r "${ZOPEN_CA}" ]] ||   printError "Certificate at ${ZOPEN_CA} could not be accessed. Ensure zopen init has run and \$HOME\zopen-config has been sourced. "
+
+export SSL_CERT_FILE="${ZOPEN_CA}"
+export GIT_SSL_CAINFO="${ZOPEN_CA}"
+export CURL_CA_BUNDLE="${ZOPEN_CA}"
+
+if [ ! -z "$filter" ]; then
+  filter=$(echo "$filter" | awk '{print tolower($0)}')
+  case "$filter" in
+      blue|green|yellow|red|skipped) ;;
+      *) printError "The filter must be one of blue|green|yellow|red"
+  esac
+fi
+
+if ! $localoption; then
+
+ # Retrieve all repositories
+ # TODO: These are causing early exists???
+ # progressHandler "network" "- Retrieved remote details" &
+ # ph=$!
+ # killph="kill -HUP $ph"
+ # addCleanupTrapCmd "$killph"
+  getReposFromGithub
+  grfgRc=$?
+  $killph 2>/dev/null  # if the timer is not running, the kill will fail
+  [ 0 -ne $grfgRc ] && exit $grfgRc;
+
+  # Parse repositories for zopen framework repos
+  foundPort=false
+  repoArray=""
+  for repo in $(echo ${repo_results}); do
+    repo=${repo#"ZOSOpenTools/"}
+    name=${repo%port}
+    printVerbose "Checking repo suffixes for '$repo' with name:'$name'"
+  
+    if [ -z "${chosenRepos}" ]; then
+      repoArray="$repoArray $repo"
+    else
+      printVerbose "Testing ${chosenRepos}"
+      for toolrepo in $(echo "${chosenRepos}" | tr ',' '\n'); do
+        if [ "${toolrepo}" = "${repo}" ] || [ "${toolrepo}" = "${name}" ]; then
+          # Skip if the repo does not end with port
+          if [ "${repo}" = "${name}" ]; then
+            continue;
+          fi
+          repoArray="$repoArray $repo"
+        fi
+      done
+    fi
+  done
+fi
+
+! $upgradeable || printDetailListEntries $details "" 1
+[ -z "$remotesearch" ] || printDetailListEntries $details $needle 0
+[ -z "$list" ] || printDetailListEntries $details "" 0
+[ -z "$installed" ] || printInstalledEntries $details "" 0
+[ -z "$whatprovides" ] || whatProvides $needle
diff --git a/bin/lib/zopen-remove b/bin/lib/zopen-remove
new file mode 100755
index 000000000..9b8ff2469
--- /dev/null
+++ b/bin/lib/zopen-remove
@@ -0,0 +1,90 @@
+#!/bin/sh
+# Removal utility for z/OS Open Tools - https://github.com/ZOSOpenTools
+
+export utildir="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
+
+. "${utildir}/common.inc"
+
+printSyntax() 
+{
+  args=$*
+  echo "zopen remove is a utility to remove installed z/OS Open Tools packages."
+  echo "Syntax: zopen remove [<option>]* <package, ...>" >&2
+  echo "  where <option> may be one or more of:" >&2
+  echo "  -p|--purge: remove package, the versioned directory and any cached file"  >&2
+  echo "  -v: run in verbose mode" >&2
+  echo "  and <package> is a list of one or more projects to uninstall" >&2
+}
+
+removePackages(){
+  pkglist=$*
+
+  echo "$pkglist" | xargs | tr ' ' '\n' | sort | while read pkg; do
+    printHeader "Removing package: $pkg"
+    printInfo "- Checking status of package '$pkg'"
+    if [ ! -f $ZOPEN_PKGINSTALL/$pkg/.active ]; then 
+      printInfo "${NC}${YELLOW}Package '$pkg' is not installed${NC}"
+    else
+      printInfo "- Package installed, unmeshing from system"
+      version="unknown"
+      if [ -e "${ZOPEN_PKGINSTALL}/${pkg}/.releaseinfo" ]; then
+        version=$(cat "${ZOPEN_PKGINSTALL}/${pkg}/.releaseinfo")
+      fi
+
+      if [ -e "$ZOPEN_PKGINSTALL/$pkg" ]; then
+        deref=$(cd $ZOPEN_PKGINSTALL/$pkg && pwd -P | awk -F/ '{ print $(NF)}')
+        installedlinksfile="$ZOPEN_PKGINSTALL/$deref/.links"
+        if $purge; then
+          printInfo "- Purging package"
+          printVerbose "Checking if we are currently in a directory that is to be purged"
+          [ "${PWD##$ZOPEN_PKGINSTALL/$pkg}" != "$PWD" ] && cd $ZOPEN_PKGINSTALL
+          rm -rf $(cd $ZOPEN_PKGINSTALL/$pkg && pwd -P)
+          syslog $ZOPEN_LOG_PATH/audit.log $LOG_A "$CAT_PACKAGE,$CAT_REMOVE" "REMOVE" "removePackage" "Purging package:'${needle};version:$version;"
+        else
+          printInfo "- Removing metadata file to mark uninstall"
+          rm -f $ZOPEN_PKGINSTALL/$pkg/.active
+          printInfo "- Breaking link from current to versioned"
+          rm -f "$ZOPEN_PKGINSTALL/$pkg/"
+        fi
+        printVerbose "Main symlink removed, removing dangling symlinks"
+        unsymlinkFromSystem "$pkg" "$ZOPEN_ROOTFS" "$installedlinksfile"
+      fi
+
+      printInfo "- Removing profiled entry"
+      [ -d "$ZOPEN_ROOTFS/etc/profiled/$pkg" ] && rm -rf "$ZOPEN_ROOTFS/etc/profiled/$pkg"
+
+      syslog "$ZOPEN_LOG_PATH/audit.log" "$LOG_A" "$CAT_PACKAGE,$CAT_REMOVE" "REMOVE" "removePackage" "Removed package:'${needle};version:$version;"
+      printInfo "${NC}${GREEN}Successfully removed: $pkg${NC}"
+    fi
+  done
+}
+
+# Main code start here
+args=$*
+
+verbose=false
+purge=false
+chosenRepos=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    "-p" | "--purge")
+      purge=true
+      ;;
+    "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+      printSyntax "${args}"
+      exit 4
+      ;;
+    "-v" | "--v" | "-verbose" | "--verbose")
+      verbose=true
+      ;;
+    *)
+      chosenRepos="$chosenRepos $1";
+      ;;
+  esac
+  shift;
+done
+
+[[ ! -z "$chosenRepos" ]] || printError "No packages selected for removal" 
+mutexReq "zopen" "zopen"
+removePackages "$chosenRepos"
+mutexFree "zopen"
diff --git a/bin/lib/zopen-update-cacert b/bin/lib/zopen-update-cacert
index 5e590e431..41e004744 100755
--- a/bin/lib/zopen-update-cacert
+++ b/bin/lib/zopen-update-cacert
@@ -2,6 +2,26 @@
 #
 # Updates the cacert in zopen meta root directory
 #
+if [ -z "$utildir" ]; then
+  export mydir="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
+else
+  mydir=$utildir
+fi
+
+. "${mydir}/common.inc"
+
+if [ -z "$ZOPEN_CA" ]; then
+  ZOPEN_CA="${mydir}/../../cacert.pem"
+fi
+
+# Temporary files
+for tmp in "$TMPDIR" "$TMP" /tmp
+do
+  if [ ! -z $tmp ] && [ -d $tmp ]; then
+    TEMP_CACERT="$tmp/$LOGNAME.$RANDOM.cacert.pem"
+    break
+  fi
+done
 
 cleanupOnExit() {
     rv=$?
@@ -33,8 +53,18 @@ getCACertFromCurl()
   # Get latest CACert from Mozilla through Curl
   printVerbose "Using $(type curl)"
   printVerbose "Downloading ${cacert_update_url}"
-  if ! curl -L $curlOptions -o "$TEMP_CACERT" "${cacert_update_url}"; then
-    return 1
+  nocertverify=""
+  if [ ! -f "$SSL_CERT_FILE" ]; then
+    printVerbose "No cacert file present"
+    if $insecureFallback; then 
+      printWarning "Using insecure fallback"
+      nocertverify="-k "
+    fi
+  fi
+  curlver="$(whence curl)"
+  printVerbose "Using curl located at: $curlver"
+  if ! $curlver -L $curlOptions $nocertverify -o "$TEMP_CACERT" ${cacert_update_url} ; then
+    printError "curl command could not download from: ${cacert_update_url}"
   fi
 
   if [ ! -f $TEMP_CACERT ]; then
@@ -52,7 +82,7 @@ updateCACert()
 export mydir="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
 
 . "${mydir}/common.inc"
-
+verbose=false
 export default_dir="$( cd "${mydir}/../../" && pwd -P )"
 export cacert_update_url="https://curl.se/ca/cacert.pem"
 
@@ -72,6 +102,7 @@ fi
 dir="${default_dir}"
 args=$*
 forceUpdate=false
+insecureFallback=false
 while [[ $# -gt 0 ]]; do
   case "$1" in
     "-f" | "-force" | "--force")
@@ -81,6 +112,9 @@ while [[ $# -gt 0 ]]; do
       printHelp "${args}"
       exit 4
       ;;
+    "-i" | "--insecure-fallback")
+      insecureFallback=true
+      ;;
     "-v" | "--v" | "-verbose" | "--verbose")
       verbose=true
       ;;
@@ -97,7 +131,7 @@ while [[ $# -gt 0 ]]; do
   shift;
 done
 
-ZOPEN_CA="${dir}/cacert.pem"
+#ZOPEN_CA="${dir}/cacert.pem"
 
 if ! [ -r "${ZOPEN_CA}" ]; then
   forceUpdate=true 
diff --git a/bin/zopen b/bin/zopen
index e81cb7813..410656ed0 100755
--- a/bin/zopen
+++ b/bin/zopen
@@ -4,70 +4,118 @@
 #
 printSyntax()
 {
-  echo "" >&2
-  echo "Syntax: zopen <command>" >&2
-  echo "where <command> is one of the following:" >&2
-  echo "  build          Invokes the build script" >&2
-  echo "  generate       Generate a zopen project" >&2
-  echo "  init           Generate a $HOME/.zopen-config file" >&2
-  echo "  install        Downloads and installs z/OS Open Tools" >&2
-  echo "  update-cacert  Updates the cacert.pem file" >&2
-  echo "  upgrade        Upgrades already installed tools" >&2
+  printInfo "" >&2
+  printInfo "Syntax: ${NC}${BOLD}zopen <command>${NC}" >&2
+  printInfo "where ${NC}${BOLD}<command>${NC} may be one of the following:" >&2
+  printInfo "  ${NC}${BOLD}init         ${NC}   generate \$HOME/.zopen-config, creates file structure and bootstraps" >&2
+  printInfo "  ${NC}${BOLD}build        ${NC}   invokes the build script." >&2
+  printInfo "  ${NC}${BOLD}download     ${NC}   downloads z/OS Open Tools package(s)" >&2
+  printInfo "  ${NC}${BOLD}install      ${NC}   installs z/OS Open Tools package(s))" >&2
+  printInfo "  ${NC}${BOLD}generate     ${NC}   generate a zopen project" >&2
+  printInfo "  ${NC}${BOLD}update-cacert${NC}   update the cacert.pem file" >&2
+  printInfo "  ${NC}${BOLD}upgrade      ${NC}   upgrades already installed tools" >&2
+  printInfo "  ${NC}${BOLD}list         ${NC}   lists information about z/OS Open Tools packages" >&2
+  printInfo "  ${NC}${BOLD}query        ${NC}   queries z/OS Open Tools packages" >&2
+  printInfo "  ${NC}${BOLD}search       ${NC}   searches remote repo for z/OS Open Tools package" >&2
+  printInfo "  ${NC}${BOLD}remove       ${NC}   removes installed z/OS Open Tools packages" >&2
+  printInfo "  ${NC}${BOLD}alt          ${NC}   switch local versions of z/OS Open Tools packages" >&2
+  printInfo "  ${NC}${BOLD}clean        ${NC}   cleans various aspects of z/OS Open Tools packages" >&2
   echo "" >&2
 }
 
-printHelp()
+printHelp() 
 {
   args=$*
-  echo "zopen is a general purpose script to be used with the ZOSOpenTools ports." >&2
+  echo "zopen is a general purpose script to be used with the z/OS Open Tools ports." >&2
   printSyntax
   echo "Example usage:" >&2
-  echo "  # Build a port" >&2
-  echo "  zopen build -v # Build port" >&2
-  echo "  # List available ports to install" >&2
-  echo "  zopen install" >&2
-  echo "  # Install all the ports from Github" >&2
-  echo "  zopen install --all" >&2
-  echo "  # Generate a zopen template project" >&2
-  echo "  zopen generate" >&2
+  echo " # Install the 'which' utility package" >&2
+  echo " zopen install which" >&2
+  echo " # List available packages to download" >&2
+  echo " zopen list" >&2
+  echo " # List currently installed packages" >&2
+  echo " zopen list --installed" >&2
+  echo " # Generate a zopen template project" >&2
+  echo " zopen generate" >&2
 }
 
 export bindir="$( cd "$(dirname "$0")" >/dev/null 2>&1 && pwd -P )"
 . "${bindir}/lib/common.inc"
 
 args=$*
+legacy=false
 while [[ $# -gt 0 ]]; do
   case "$1" in
+    "--legacy")
+      shift
+      legacy=true
+    ;;
+    "alt")
+      shift
+      exec "${bindir}/lib/zopen-alt" $@
+      ;;
     "build")
       shift
       exec "${bindir}/lib/zopen-build" $@
       ;;
-    "install")
+    "clean")
       shift
-      exec "${bindir}/lib/zopen-install" $@
+      exec "${bindir}/lib/zopen-clean" $@
       ;;
-    "upgrade")
+    "download")
       shift
-      exec "${bindir}/lib/zopen-install" -u $@
+      exec "${bindir}/lib/zopen-download" $@
       ;;
     "generate")
       shift
       exec "${bindir}/lib/zopen-generate" $@
       ;;
+    "help" | "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
+      printHelp "${args}"
+      exit 0
+      ;;
+    "init")
+      shift
+      if $legacy; then
+        exec "${bindir}/lib/zopen-init --legacy" $@
+      else
+        exec "${bindir}/lib/zopen-init" $@
+      fi
+      ;;
+    "install" | "-i")
+      shift
+      if $legacy; then
+        exec "${bindir}/lib/zopen-install" $@
+      else
+        exec "${bindir}/lib/zopen-download" $@
+      fi
+      ;;
+    "list" | "-l")
+      shift
+      exec "${bindir}/lib/zopen-query" "--list" $@
+      ;;
+    "query" | "-q")
+      shift
+      exec "${bindir}/lib/zopen-query" $@
+      ;;
+    "remove" | "-r" | "uninstall" | "un" | "erase" | "e")
+      shift
+      exec "${bindir}/lib/zopen-remove" $@
+      ;;
+    "search" | "-s")
+      shift
+      exec "${bindir}/lib/zopen-query" --remote-search $@
+      ;;
     "update-cacert")
       shift
       exec "${bindir}/lib/zopen-update-cacert" $@
       ;;
-    "init")
+    "upgrade" | "up")
       shift
-      exec "${bindir}/lib/zopen-init" $@
-      ;;
-    "help" | "-h" | "--h" | "-help" | "--help" | "-?" | "-syntax")
-      printHelp "${args}"
-      exit 0
+      exec "${bindir}/lib/zopen-download" -u $@
       ;;
     *)
-      printSoftError "Unknown option specified: '${1}'"
+      printSoftError "Unknown option ${1} specified"
       printSyntax "${args}"
       exit 8
       ;;
diff --git a/docs/Guides/FAQ.md b/docs/Guides/FAQ.md
index 82ffbd1f4..ea491e789 100644
--- a/docs/Guides/FAQ.md
+++ b/docs/Guides/FAQ.md
@@ -16,9 +16,6 @@ If the issue pertains to a given project, open the issue in the project's Github
 ## What is the current porting status?
 Overall status for the z/OS Open Tools initiative is available [here](https://zosopentools.github.io/meta/#/Progress).
 
-## How do I view the status of my build in Jenkins?
-The external Jenkins page can be accessed [here](https://163.74.88.212:8443/).
-
 ## What are the z/OS Open Source Guild Meetings?
 The z/OS Open Source Guild meetings are monthly meetings where we cover highlights in z/OS Open Source. To view past recordings and slides, visit [https://github.com/ZOSOpenTools/meta/discussions/categories/guild](https://github.com/ZOSOpenTools/meta/discussions/categories/guild).
 
diff --git a/docs/Guides/Pipeline.md b/docs/Guides/Pipeline.md
index 6d0f63ddb..e2f2ec8e9 100644
--- a/docs/Guides/Pipeline.md
+++ b/docs/Guides/Pipeline.md
@@ -6,11 +6,9 @@
 
 The z/OS Open Tools CI/CD pipeline leverages Wazi as a Service instances to be able to build, test, and deploy ported packages to Github Releases.
 
-There is currently one z/OS node set up under the ip address `128.168.143.139`. 
-
 ### z/OS Open Tools Jenkins CI/CD Pipeline
 
-Access the Jenkins CI/CD Pipeline at https://163.74.88.212:8443.  To be able to view/launch Jenkins CI/CD jobs, you must first log-in with your w3id (currently IBM Internal)
+Access to the Jenkins CI/CD Pipeline is currently restricted.  To be able to view/launch Jenkins CI/CD jobs, you must first log-in with your w3id (currently IBM Internal)
 
 ### Overview of Jenkins CI/CD jobs
 
@@ -43,7 +41,3 @@ To manually start a build, locate your port from the _Port_ view: `https://163.7
 
 Click on the arrow pointing downwards and select *Build Now*. This will launch a build of your port.
 
-
-### Slack Build Status Notifications
-A slack notification is currently set up to post build status on the [#zos-opentools-builds](https://ibm-systems-z.slack.com/archives/C03QBPC863E) slack channel.
-
diff --git a/docs/Guides/Porting.md b/docs/Guides/Porting.md
index 0e6e214f9..5df6f0fff 100644
--- a/docs/Guides/Porting.md
+++ b/docs/Guides/Porting.md
@@ -32,18 +32,13 @@ Many tools require a C or C++ compiler (or both) to build. There a couple of opt
 Please note that these compilers are comparable, but how you perform installation and maintenance and pricing is different.
 
 In order for zopen to be able to locate dependent tools, they need to be in well-defined locations.
-Tools will be searched for in the following default locations, in order:
-- `${HOME}/zopen/prod/<tool>`
-- `${HOME}/zopen/boot/<tool>`
 
-You can configure this location by running `zopen init` to reconfigure the location.
+Dependencies will be searched for in the following default locations:
+- `${ZOPEN_PKGINSTALL}` as configured in your $HOME/.zopen-config configuration.
 
-Let's take a look at an example. `git` depends on `make` to build, as specified in the [gitport dependencies](https://github.com/ZOSOpenTools/gitport/blob/main/buildenv#L10). 
-`zopen build` will search for `make` first in the
-personal _prod_ build from `${HOME}/zopen/prod/m4`, then finally in the personal _boot_ directory `${HOME}/zopen/boot/m4`. Symbolic links can be used as required to share builds between developers on a system, if desired.  You can also add your own directories to the search path by specifying the -d option to `zopen build` as follows:
-```bash
-zopen build -d $HOME/mytools
-```
+You can change this location by running `zopen init` to reconfigure the install directory.
+
+If the tool is not found, then `zopen build` will automatically install it.
 
 Each tool is responsible for knowing how to set it's own environment up (e.g. PATH, LIBPATH, and any other environment variables).
 By default, `zopen build` will automatically add PATH, LIBPATH, and MANPATH environment variables. If other environment variables are needed, then you can append them by defining a `zopen_append_to_env` function as in the case of [gitport](https://github.com/ZOSOpenTools/gitport/blob/main/buildenv#LL66-L66C20).
diff --git a/docs/Guides/Pre-req.md b/docs/Guides/Pre-req.md
index 189ddb553..fa8ce69bc 100644
--- a/docs/Guides/Pre-req.md
+++ b/docs/Guides/Pre-req.md
@@ -18,35 +18,7 @@ We recommend adding these environment variables to your `.profile` or `.bashrc`
 
 ## Required Tools
 
-### If you only want to _use_ Open Source Tools
-
-**NOTE:** These tools are unsupported. Use them at your own discretion. While we find them extremely helpful, they have bugs and are unsupported. If you encounter problems, please tell us by opening issues in the GitHub repository for the tool you are having issues with. For general problems, open an issue in the [meta](https://github.com/ZOSOpenTools/meta/issues) repository.
-
-For new ideas, general feedback, or to start a discussion, please see our [discussions](https://github.com/ZOSOpenTools/meta/discussions).
-
-#### Install curl on z/OS
-
-You will need _curl 7.77_ or later on your z/OS system so that you can download the individual Open Source packages from github. 
-If you don't have curl on z/OS, you will need to download it to your desktop then use _sftp_ to upload it to z/OS and then use _pax_ to decompress it:
-- Download ['boot curl'](https://github.com/ZOSOpenTools/curlport/releases/tag/boot)
-- Upload the pax file: `sftp <your host>`
-- decompress the pax file: `pax -rf <pax file>`
-- `cd curl*`
-- add curl to your environment: `. ./.env`
-
-Once you have curl, you can now install other tools from the community.
-
-#### Install other tools
-
-All the tools are at: [ZOSOpenTools](https://github.com/ZOSOpenTools?tab=repositories)
-
-- Click on the repository of the tool you want. For example, the [bashport](https://github.com/ZOSOpenTools/bashport) has bash.
-- Click on the _tag_ link to see the tagged releases. For example, the [bashport tags](https://github.com/ZOSOpenTools/bashport/tags) shows the builds for bash.
-- Click the tag of the release you want (likely the most recent). For example: [bashport build 223](https://github.com/ZOSOpenTools/bashport/releases/tag/bashport_223)
-- Cut and paste the download and install command to your z/OS system to install the tool on z/OS
-  - This command will use curl to download the pax file, unpax the file, cd into the tool directory and source `.env` in that directory to set up your environment
-
-For more details, visit https://github.com/ZOSOpenTools/meta.
+To consume z/OS Open Tools, all you need is a z/OS UNIX system and unrestricted access to github.com.
 
 ### If you want to contribute and improve the z/OS Open Source Tools 
 
@@ -66,16 +38,21 @@ For more details on porting, visit the [porting to z/OS guide](Porting.md).
 
 Once you have your development environment set up, you can install tools directly to z/OS with `zopen install`.
 
-To download and install the latest software packages, enter the command `zopen install`. By default it will list all of the tools hosted on ZOSOpenTools.
-
-To download the available packages, specify the --all option as follows:
-
+Prior to installing tools, you need to initialize your z/OS Open Tools environment:
 ```bash
-zopen install --all
+zopen init
 ```
 
+To download and install the latest software packages, enter the command `zopen install`.
+
 To download and install specific packages, specify them as a comma delimited list as follows:
 ```bash
 zopen install make,curl,gzip
 ```
+
+To download the available packages, specify the --all option as follows:
+
+```bash
+zopen install --all
+```
 For more details, see the section on [zopen tools](zopen.md).
diff --git a/docs/Guides/QuickStart.md b/docs/Guides/QuickStart.md
index d114d8908..84060f3ba 100644
--- a/docs/Guides/QuickStart.md
+++ b/docs/Guides/QuickStart.md
@@ -3,51 +3,40 @@
 z/OS Open Tools lets you install unsupported Open Source tools that run native on your z/OS system. 
 Whether you want to strictly _use_ the tools or also _improve_ the tools is up to you.
 
-The easiest way to install and build software packages from z/OS Open Tools is to setup the _zopen tools_ on your z/OS system.
+## Getting meta
 
-We provide a program called `zopen-setup` so you can _bootstrap_ your z/OS system. Your z/OS system will need external connectivity since `zopen-setup` will connect to [z/OS Open Tools repositories](https://github.com/ZOSOpenTools). 
+Download [meta](https://github.com/ZOSOpenTools/meta/releases/download/TDB) to z/OS.
 
-## Getting zopen-setup
+Expand the pax using the command ```pax -rvf <filename>.pax```.  This will expand the pax to the current directory, listing the various included files as it does so.
 
-Download [zopen-setup](https://github.com/ZOSOpenTools/meta/releases/download/v1.0.0/zopen-setup) to z/OS, mark the program executable, and run it. Detailed instructions follow.
+Source the .env to pick up the zopen environment:
+```bash
+. ./..env
+```
 
-### Getting zopen-setup to your z/OS system
+Now initialize your environment with zopen init:
+```bash
+zopen init
+```
 
-Note: In the documentation that follows, text inside `< ... >` indicates a value you need to provide, e.g. `<z/OS system>` would be replaced with the name of the z/OS system you are using.
+This will create a $HOME/.zopen-config configuration. You can source this in your envrionment or add it to your .bashrc or .profile.
 
-To get started, you need to get the _zopen-setup_ program to your z/OS system. Here is one approach:
-- Log on to your desktop system
-- Download [zopen-setup](https://github.com/ZOSOpenTools/meta/releases/download/v1.0.0/zopen-setup)
-- Open a terminal window on your desktop 
-- `cd` into the directory you downloaded the file to
-- `sftp <z/OS system>`
-- Log in if required
-- `put zopen-setup`
-- `quit`
-- `ssh <z/OS system>`
-- log in if required
-- `cd $HOME`
-- `chmod u+x zopen-setup` # mark the program executable
+```bash
+. $HOME/.zopen-config
+```
 
-If you don't have ssh, scp, sftp access to your z/OS system, we would encourage you to set it up. 
-It will be much easier to work with USS using ssh, scp, and sftp.
+You are now free to install any z/OS Open Tools via `zopen install`.
 
-### Running zopen-setup
-
-- `cd $HOME`
-- `./zopen-setup  <file system>` # file system is the location where the zopen tools will be installed
-
-### Set up the zopen tools
-
-Your zopen tools environment has been downloaded but not yet set up. Before starting the setup, make sure that the environment variable `_BPXK_AUTOCVT` is set to ON.
-
-To set up the environment:
-- `cd $HOME/zopen/boot`
-- `. ./.bootenv` # add the tools zopen needs to function, as well as zopen (don't forget the leading '.' which sources the script)
-
-Each time you log on, you will need to set up your boot environment before you can use zopen. You do this the same way as your initial setup:
-- `cd $HOME/zopen/boot`
-- `. ./.bootenv`
+## Sample usage
+```
+>./zopen init
+>. $HOME/.zopen-config
+>./zopen list --installed
+>zopen install which
+>zopen list --installed
+>which which
+>zopen upgrade
+```
 
 You are now ready to _use_ or _improve_ the tools you want.
 
diff --git a/packages/curl-8.1.2.20230707_145137.zos.pax.Z b/packages/curl-8.1.2.20230707_145137.zos.pax.Z
new file mode 100644
index 000000000..9cf50c362
Binary files /dev/null and b/packages/curl-8.1.2.20230707_145137.zos.pax.Z differ
diff --git a/packages/jq-1.6.20230720_160648.zos.pax.Z b/packages/jq-1.6.20230720_160648.zos.pax.Z
new file mode 100644
index 000000000..787b71b6c
Binary files /dev/null and b/packages/jq-1.6.20230720_160648.zos.pax.Z differ